{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-Network Variant Dueling DQN implementation (PyTorch).\n",
    "\n",
    "In this notebook, we will implement Dueling DQN variant of DQN. First part of the notebook is all about the vanilla DQN and how we train - a copy of `6_1_dqn_pytorch.ipynb`. The Dueling DQN variant is after these sections on vanilla DQN. \n",
    "\n",
    "\n",
    "\n",
    "### RECAP\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max}$$\n",
    "\n",
    "Q Learning control is carried out by sampling step by step and updating Q values at each step. We use ε-greedy policy to explore and generate samples. However, the policy learnt is a deterministic greedy policy with no exploration. We can carryout updates online i.e. we take a step and use `(current state, action, reward and next_state)` tuple to update. \n",
    "\n",
    "In case of function approximation using neural network, the input to the network is the state and output is the q(s,a) for all the actions in the state `s`. It is denoted as $ \\hat{q}(s_t,a; w_{t}) $, where $w_{t}$ is the weights of the neural network which we are trying to learn as part of DQN learning. \n",
    "\n",
    "We use two networks, one target network to get the max q-value of next state denoted by $ \\max_a \\hat {q}(s_{t+1},a; w^{-}_{t}) $ and the primary network with weights $w_{t}$ which we are updated based on back propagation of the TD error through the network.\n",
    "\n",
    "The Update equation is given below. This is the online version:\n",
    "$$ w_{t+1} \\leftarrow w_t + \\alpha [ R_{t+1} + \\gamma . \\max_{a} \\hat{q}(S_{t+1},a,w^{-}_{t}) – \\hat{q}(S_t,A_t,w_t)] \\nabla \\hat{q}(S_t,A_t,w_t)$$\n",
    "\n",
    "Online update with neural network with millions of weights does not work well. Accordingly, We use experience replay (aka Replay Buffer).  We use a behavior policy to explore the environment and store the samples `(s, a, r, s', done)` in a buffer. The samples are generated using an exploratory behavior policy while we improve a deterministic target policy using q-values. \n",
    "\n",
    "Therefore, we can always use older samples from behavior policy and apply them again and again. We can keep the buffer size fixed to some pre-determined size and keep deleting the older samples as we collect new ones. This process makes learning sample efficient by reusing a sample multiple times and also removing temporal dependence of the samples we would otherwise see while following a trajectory.\n",
    "\n",
    "The update equation with batch update with minor modifications is given below. We collect samples of transitions (current state, action, reward, next state) in a buffer. Where each sample is denoted as a tuple: \n",
    "\n",
    "$$ (s_{i}, a_{i}, r_{i}, s^{'}_{i}, done_{i})$$\n",
    "\n",
    "Subscript (i) denotes ith sample. We take N samples from experience replay selecting randomly and update the weights. Subscript (t) denotes the index of weight updates. If the current state is done, as denoted by `done` flag, the target is just the reward as terminal states have zero value. The final update equation is as given below:\n",
    "\n",
    "$$w_{t+1} \\leftarrow w_t + \\alpha \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import gym\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.signal import convolve, gaussian\n",
    "import math\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "from tqdm import trange\n",
    "import glob\n",
    "import random\n",
    "from collections import namedtuple\n",
    "\n",
    "from IPython.display import HTML, clear_output\n",
    "\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - CartPole \n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are discrete. We will build it on Cart Pole and they try to run this on many other environments like Lunar Lander and others.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW4AAAD8CAYAAABXe05zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAATIklEQVR4nO3db4xd9X3n8fcHAwYBbUwZWMc2azcxq0K2NdHIG4ltSwMtLFR18iArI23kB0TOA0cK2ipdaKVt8sBSd9Ukq0ibSGSDamXTEEsJi4PS3RI3URoti2MIEGzj4AQvntixjQMYaDC257sP5rBc7BnP9fzJ+Df3/ZKu7jnf8zv3fn/IfHz8m3PnpqqQJLXjvLluQJJ0dgxuSWqMwS1JjTG4JakxBrckNcbglqTGzFpwJ7k1ye4ke5LcPVvvI0mDJrNxH3eSBcCPgT8ERoAfAHdU1c4ZfzNJGjCzdcW9GthTVT+tqjeA+4E1s/RekjRQzp+l110C7OvZHwH+1USDr7jiilq+fPkstSJJ7dm7dy8vvPBCxjs2W8E93pu9bU0myXpgPcDVV1/N9u3bZ6kVSWrP8PDwhMdma6lkBFjWs78U2N87oKrurarhqhoeGhqapTYkaf6ZreD+AbAyyYokFwJrgS2z9F6SNFBmZamkqk4k+Rjwv4AFwH1VtWM23kuSBs1srXFTVd8CvjVbry9Jg8pPTkpSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5Jasy0vrosyV7gFeAkcKKqhpNcDnwNWA7sBf5tVb04vTYlSW+aiSvuP6iqVVU13O3fDWytqpXA1m5fkjRDZmOpZA2wqdveBHxgFt5DkgbWdIO7gL9P8liS9V3tqqo6ANA9XznN95Ak9ZjWGjdwQ1XtT3Il8HCSZ/o9sQv69QBXX331NNuQpMExrSvuqtrfPR8CHgBWAweTLAbong9NcO69VTVcVcNDQ0PTaUOSBsqUgzvJJUkue3Mb+CPgaWALsK4btg54cLpNSpLeMp2lkquAB5K8+Tp/W1X/M8kPgM1J7gSeBz40/TYlSW+acnBX1U+B3xmnfgS4aTpNSZIm5icnJakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMZMGtxJ7ktyKMnTPbXLkzyc5NnueVHPsXuS7EmyO8kts9W4JA2qfq64/wa49ZTa3cDWqloJbO32SXItsBa4rjvn80kWzFi3kqTJg7uqvgf84pTyGmBTt70J+EBP/f6qOlZVzwF7gNUz06okCaa+xn1VVR0A6J6v7OpLgH0940a62mmSrE+yPcn2w4cPT7ENSRo8M/3DyYxTq/EGVtW9VTVcVcNDQ0Mz3IYkzV9TDe6DSRYDdM+HuvoIsKxn3FJg/9TbkySdaqrBvQVY122vAx7sqa9NsjDJCmAlsG16LUqSep0/2YAkXwVuBK5IMgL8JfBXwOYkdwLPAx8CqKodSTYDO4ETwIaqOjlLvUvSQJo0uKvqjgkO3TTB+I3Axuk0JUmamJ+clKTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUmEmDO8l9SQ4lebqn9skkP0vyRPe4refYPUn2JNmd5JbZalySBlU/V9x/A9w6Tv2zVbWqe3wLIMm1wFrguu6czydZMFPNSpL6CO6q+h7wiz5fbw1wf1Udq6rngD3A6mn0J0k6xXTWuD+W5KluKWVRV1sC7OsZM9LVTpNkfZLtSbYfPnx4Gm1I0mCZanB/AXgXsAo4AHy6q2ecsTXeC1TVvVU1XFXDQ0NDU2xDkgbPlIK7qg5W1cmqGgW+yFvLISPAsp6hS4H902tRktRrSsGdZHHP7geBN+842QKsTbIwyQpgJbBtei1KknqdP9mAJF8FbgSuSDIC/CVwY5JVjC2D7AU+ClBVO5JsBnYCJ4ANVXVyVjqXpAE1aXBX1R3jlL90hvEbgY3TaUqSNDE/OSlJjTG4JakxBrckNcbglqTGGNyS1BiDWwOrqnjt0HO8dvj/znUr0lmZ9HZAaT7Z/9hDvHbwJ/9//9Wf7+Hi31jKv/iTPyMZ7zc2SOceg1sD5ZdH9nF0ZOdctyFNi0slktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuDWQLn0n737tNrx117m2FG/sFrtMLg1UH796n8Jp3xC8o1Xj/D6i341qtphcEtSYyYN7iTLknwnya4kO5J8vKtfnuThJM92z4t6zrknyZ4ku5PcMpsTkKRB088V9wngT6vqt4D3ARuSXAvcDWytqpXA1m6f7tha4DrgVuDzSRbMRvOSNIgmDe6qOlBVj3fbrwC7gCXAGmBTN2wT8IFuew1wf1Udq6rngD3A6hnuW5IG1lmtcSdZDlwPPApcVVUHYCzcgSu7YUuAfT2njXS1U19rfZLtSbYfPuxP9CWpX30Hd5JLga8Dd1XV0TMNHadWpxWq7q2q4aoaHhoa6rcNSRp4fQV3kgsYC+2vVNU3uvLBJIu744uBQ119BFjWc/pSwHutJGmG9HNXSYAvAbuq6jM9h7YA67rtdcCDPfW1SRYmWQGsBLbNXMuSNNj6+QacG4APAz9K8kRX+3Pgr4DNSe4Engc+BFBVO5JsBnYydkfKhqo6OdONS9KgmjS4q+r7jL9uDXDTBOdsBDZOoy9J0gT85KQkNcbgloCqouq0m5+kc5LBrYFy3vkLufCSRafVDz39D4xz16p0TjK4NVAuvHQRv7bsutPqx//pZXNbzTC4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1sDZ9FvDpMFb/8OkeP/9BKv7N89Rx1JZ8fg1sC5eNE7Sd7+R3/0+DGOvfLCHHUknZ1+vix4WZLvJNmVZEeSj3f1Tyb5WZInusdtPefck2RPkt1JbpnNCUjSoOnny4JPAH9aVY8nuQx4LMnD3bHPVtVf9w5Oci2wFrgOeCfw7STX+IXBkjQzJr3irqoDVfV4t/0KsAtYcoZT1gD3V9WxqnoO2AOsnolmJUlnucadZDlwPfBoV/pYkqeS3Jfkze+DWgLs6zlthDMHvSTpLPQd3EkuBb4O3FVVR4EvAO8CVgEHgE+/OXSc00/7Uqgk65NsT7L98OHDZ9u3JA2svoI7yQWMhfZXquobAFV1sKpOVtUo8EXeWg4ZAZb1nL4U2H/qa1bVvVU1XFXDQ0ND05mDJA2Ufu4qCfAlYFdVfaanvrhn2AeBp7vtLcDaJAuTrABWAttmrmVJGmz93FVyA/Bh4EdJnuhqfw7ckWQVY8sge4GPAlTVjiSbgZ2M3ZGywTtKJGnmTBrcVfV9xl+3/tYZztkIbJxGX5KkCfjJSUlqjMEtSY0xuDV4Es47/8LTyqMnjlF12p2r0jnH4NbAOf+iS7nit373tPqhH21l9MQbc9CRdHYMbg2cJOS8038uP3ryxBx0I509g1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUmH5+ravUhNHRUe666y727ds36djfffcl/P7KS95We+mlF7njjjs4frK/j71v2LCBm2++eUq9StNhcGte2bp1Kzt37px03NDt7+X33j3M8VpI1Xkko7z++ot885vf5PU3+vsE5e233z7ddqUpMbg1kAp46fiVPP7iTbxRF3FBjvFrJ7dRbJ7r1qRJGdwaSCdrAT986Q/45ehl3f4FHH71tykWzHFn0uT84aQG0jf/94954ZW3f6PeZZdcxg3Dvz9HHUn96+fLgi9Ksi3Jk0l2JPlUV788ycNJnu2eF/Wcc0+SPUl2J7llNicgTcXLr73OhRx9W23h+SdZsejFOepI6l8/V9zHgPdX1e8Aq4Bbk7wPuBvYWlUrga3dPkmuBdYC1wG3Ap9P4r8/dU5ZkJO8d9FWLr/wAOePvsDRX+zi13/5IK+89tpctyZNqp8vCy7g1W73gu5RwBrgxq6+Cfgu8B+6+v1VdQx4LskeYDXwyETvcfz4cX7+859PbQZSZ3R0lBMn+rsj5PiJk3zxf3ybiy78LkeO/pJ/fOp5Qp3VN+AcPXrUP7eaNcePH5/wWF8/nOyumB8D3g3816p6NMlVVXUAoKoOJLmyG74E+D89p490tQkdOXKEL3/5y/20Ik2oqnj55Zf7GntytPi7R599+/ln+X6PPPIIJ0+enHygNAVHjhyZ8FhfwV1VJ4FVSd4BPJDkPWcYnvFe4rRByXpgPcDVV1/NJz7xiX5akSY0OjrKpk2bOHjw4K/k/W655RY+8pGP/EreS4Pna1/72oTHzuqukqp6ibElkVuBg0kWA3TPh7phI8CyntOWAvvHea17q2q4qoaHhobOpg1JGmj93FUy1F1pk+Ri4GbgGWALsK4btg54sNveAqxNsjDJCmAlsG2G+5akgdXPUsliYFO3zn0esLmqHkryCLA5yZ3A88CHAKpqR5LNwE7gBLChW2qRJM2Afu4qeQq4fpz6EeCmCc7ZCGycdneSpNP4yUlJaozBLUmN8ZdMaV656aabuOaaa34l77V8+fJfyftIpzK4NW+cd955fO5zn5vrNqRZ51KJJDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSYwxuSWpMP18WfFGSbUmeTLIjyae6+ieT/CzJE93jtp5z7kmyJ8nuJLfM5gQkadD08/u4jwHvr6pXk1wAfD/J33XHPltVf907OMm1wFrgOuCdwLeTXOMXBkvSzJj0irvGvNrtXtA96gynrAHur6pjVfUcsAdYPe1OJUlAn2vcSRYkeQI4BDxcVY92hz6W5Kkk9yVZ1NWWAPt6Th/papKkGdBXcFfVyapaBSwFVid5D/AF4F3AKuAA8OlueMZ7iVMLSdYn2Z5k++HDh6fQuiQNprO6q6SqXgK+C9xaVQe7QB8FvshbyyEjwLKe05YC+8d5rXurariqhoeGhqbSuyQNpH7uKhlK8o5u+2LgZuCZJIt7hn0QeLrb3gKsTbIwyQpgJbBtRruWpAHWz10li4FNSRYwFvSbq+qhJF9OsoqxZZC9wEcBqmpHks3ATuAEsME7SiRp5kwa3FX1FHD9OPUPn+GcjcDG6bUmSRqPn5yUpMYY3JLUGINbkhpjcEtSYwxuSWqMwS1JjTG4JakxBrckNcbglqTGGNyS1BiDW5IaY3BLUmMMbklqjMEtSY0xuCWpMQa3JDXG4JakxhjcktQYg1uSGmNwS1JjDG5JaozBLUmNSVXNdQ8kOQy8Brww173MgitwXq2Zr3NzXm3551U1NN6BcyK4AZJsr6rhue5jpjmv9szXuTmv+cOlEklqjMEtSY05l4L73rluYJY4r/bM17k5r3ninFnjliT151y64pYk9WHOgzvJrUl2J9mT5O657udsJbkvyaEkT/fULk/ycJJnu+dFPcfu6ea6O8ktc9P15JIsS/KdJLuS7Ejy8a7e9NySXJRkW5Inu3l9qqs3Pa83JVmQ5IdJHur258u89ib5UZInkmzvavNiblNSVXP2ABYAPwF+E7gQeBK4di57msIcfg94L/B0T+0/A3d323cD/6nbvrab40JgRTf3BXM9hwnmtRh4b7d9GfDjrv+m5wYEuLTbvgB4FHhf6/Pqmd+/B/4WeGi+/Fns+t0LXHFKbV7MbSqPub7iXg3sqaqfVtUbwP3Amjnu6axU1feAX5xSXgNs6rY3AR/oqd9fVceq6jlgD2P/Dc45VXWgqh7vtl8BdgFLaHxuNebVbveC7lE0Pi+AJEuB24H/1lNufl5nMJ/ndkZzHdxLgH09+yNdrXVXVdUBGAtA4Mqu3uR8kywHrmfs6rT5uXXLCU8Ah4CHq2pezAv4L8CfAaM9tfkwLxj7y/XvkzyWZH1Xmy9zO2vnz/H7Z5zafL7Npbn5JrkU+DpwV1UdTcabwtjQcWrn5Nyq6iSwKsk7gAeSvOcMw5uYV5I/Bg5V1WNJbuznlHFq59y8etxQVfuTXAk8nOSZM4xtbW5nba6vuEeAZT37S4H9c9TLTDqYZDFA93yoqzc13yQXMBbaX6mqb3TleTE3gKp6CfgucCvtz+sG4E+S7GVsyfH9Sf477c8LgKra3z0fAh5gbOljXsxtKuY6uH8ArEyyIsmFwFpgyxz3NBO2AOu67XXAgz31tUkWJlkBrAS2zUF/k8rYpfWXgF1V9ZmeQ03PLclQd6VNkouBm4FnaHxeVXVPVS2tquWM/X/0D1X172h8XgBJLkly2ZvbwB8BTzMP5jZlc/3TUeA2xu5Y+AnwF3PdzxT6/ypwADjO2N/0dwK/AWwFnu2eL+8Z/xfdXHcD/2au+z/DvP41Y/+8fAp4onvc1vrcgN8GftjN62ngP3b1pud1yhxv5K27SpqfF2N3nT3ZPXa8mRPzYW5TffjJSUlqzFwvlUiSzpLBLUmNMbglqTEGtyQ1xuCWpMYY3JLUGINbkhpjcEtSY/4fy1bGP24VbYUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ENV_NAME = 'CartPole-v1'\n",
    "\n",
    "env = make_env(ENV_NAME)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, n_actions = env.observation_space.shape, env.action_space.n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network using pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us build a DQN agent using a simple network. We now need to build a neural network that can map states/observations to state q-values. The observation space and action space is as given below for CartPole\n",
    "\n",
    "    Observation:\n",
    "        Type: Box(4)\n",
    "        Num     Observation               Min                     Max\n",
    "        0       Cart Position             -4.8                    4.8\n",
    "        1       Cart Velocity             -Inf                    Inf\n",
    "        2       Pole Angle                -0.418 rad (-24 deg)    0.418 rad (24 deg)\n",
    "        3       Pole Angular Velocity     -Inf                    Inf\n",
    "    Actions:\n",
    "        Type: Discrete(2)\n",
    "        Num   Action\n",
    "        0     Push cart to the left\n",
    "        1     Push cart to the right\n",
    "        \n",
    "\n",
    "The model will be a simple one with 2 hidden payers with Relu activation and final layer being logits with dimension equation to number of actions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc3 = nn.Linear(128, 32)\n",
    "        self.q = nn.Linear(32, n_actions)\n",
    "        \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        qvalues = self.q(x)\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = DQNAgent(state_shape, n_actions, epsilon=0.5).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(env, agent, n_games=1, greedy=False, t_max=10000):\n",
    "    rewards = []\n",
    "    for _ in range(n_games):\n",
    "        s = env.reset()\n",
    "        reward = 0\n",
    "        for _ in range(t_max):\n",
    "            qvalues = agent.get_qvalues([s])\n",
    "            action = qvalues.argmax(axis=-1)[0] if greedy else agent.sample_actions(qvalues)[0]\n",
    "            s, r, done, _ = env.step(action)\n",
    "            reward += r\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        rewards.append(reward)\n",
    "    return np.mean(rewards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.0\n"
     ]
    }
   ],
   "source": [
    "print(evaluate(env, agent, n_games=1))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy (epsilon greedy) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n",
    "We have modified the implementation a bit to make it more efficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "           self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_and_record(start_state, agent, env, exp_replay, n_steps=1):\n",
    "\n",
    "    s = start_state\n",
    "    sum_rewards = 0\n",
    "\n",
    "    # Play the game for n_steps and record transitions in buffer\n",
    "    for _ in range(n_steps):\n",
    "        qvalues = agent.get_qvalues([s])\n",
    "        a = agent.sample_actions(qvalues)[0]        \n",
    "        next_s, r, done, _ = env.step(a)\n",
    "        sum_rewards += r\n",
    "        exp_replay.add(s, a, r, next_s, done)\n",
    "        if done:\n",
    "            s = env.reset()\n",
    "        else:\n",
    "            s = next_s\n",
    "        \n",
    "    return sum_rewards, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Target network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "target_network = DQNAgent(agent.state_shape, agent.n_actions, epsilon=0.5).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Learning with... Q-learning\n",
    "Here we write a function similar to tabular q-learning. We will calculate average TD error per batch using the equation: \n",
    "\n",
    "$$ L =  \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right]^2$$\n",
    "\n",
    "\n",
    "$$ \\nabla_w L =   - \\frac{1}{N} \\sum_{i=1}^{N} \\left[ r_i + \\left( (1-done_i) . \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t}) \\right) – \\hat{q}(s_i,a_i;w_t) \\right] \\nabla \\hat{q}(s_i,a_i;w_t)$$\n",
    "\n",
    "\n",
    "$\\hat{q}(s',A;w^{-})$ is calculated using target network whose weights are held constant and refreshed periodically from the agent learning network. \n",
    "\n",
    "Target is given by following:\n",
    "* non terminal state: $r_i +  \\gamma .  \\max_{a^{'}} \\hat{q}(s_{i}^{'},a^{'};w^{-}_{t})$\n",
    "* terminal state: $ r_i $\n",
    "\n",
    "We then carryout back propagation through the agent network to update the weights using equation below:\n",
    "\n",
    "\n",
    "$$ \n",
    "\\DeclareMathOperator*{\\max}{max} w_{t+1} \\leftarrow w_t - \\alpha \\nabla_{w}L$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def td_loss_dqn(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma=0.99, device=device):\n",
    "\n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, device=device, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, device=device, dtype=torch.long)\n",
    "    rewards = torch.tensor(rewards, device=device, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, device=device, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),device=device,dtype=torch.float)\n",
    "\n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q_s = agent(states)\n",
    "\n",
    "    # select q-values for chosen actions\n",
    "    q_s_a = q_s[range(\n",
    "        len(actions)), actions]\n",
    "\n",
    "    with torch.no_grad():\n",
    "        # compute q-values for all actions in next states\n",
    "        # use target network\n",
    "        q_s1 = target_network(next_states)\n",
    "\n",
    "\n",
    "        # compute Qmax(next_states, actions) using predicted next q-values\n",
    "        q_s1_a1max,_ = torch.max(q_s1, dim=1)\n",
    "\n",
    "        # compute \"target q-values\" \n",
    "        target_q = rewards + gamma * q_s1_a1max * (1-done_flags)\n",
    "\n",
    "    # mean squared error loss to minimize\n",
    "    loss = torch.mean((q_s_a - target_q.detach()) ** 2)\n",
    "\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def epsilon_schedule(start_eps, end_eps, step, final_step):\n",
    "    return start_eps + (end_eps-start_eps)*min(step, final_step)/final_step\n",
    "\n",
    "def smoothen(values):\n",
    "    kernel = gaussian(100, std=100)\n",
    "    kernel = kernel / np.sum(kernel)\n",
    "    return convolve(values, kernel, 'valid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main loop\n",
    "\n",
    "We now carryout the training on DQN setup above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_agent(env, agent, target_network, optimizer, td_loss_fn):\n",
    "    \n",
    "    state = env.reset()\n",
    "    # let us fill experience replay with some samples using full random policy\n",
    "    exp_replay = ReplayBuffer(10**4)\n",
    "    for i in range(100):\n",
    "        play_and_record(state, agent, env, exp_replay, n_steps=10**2)\n",
    "        if len(exp_replay) == 10**4:\n",
    "            break\n",
    "    print('Finished filling buffer with: {} samples'.format(len(exp_replay)))\n",
    "\n",
    "    mean_rw_history = []\n",
    "    td_loss_history = []\n",
    "    state = env.reset()\n",
    "    for step in trange(total_steps + 1):\n",
    "\n",
    "        # reduce exploration as we progress\n",
    "        agent.epsilon = epsilon_schedule(start_epsilon, end_epsilon, step, eps_decay_final_step)\n",
    "\n",
    "        # take timesteps_per_epoch and update experience replay buffer\n",
    "        _, state = play_and_record(state, agent, env, exp_replay, timesteps_per_epoch)\n",
    "\n",
    "        # train by sampling batch_size of data from experience replay\n",
    "        states, actions, rewards, next_states, done_flags = exp_replay.sample(batch_size)\n",
    "\n",
    "\n",
    "        # loss = <compute TD loss>\n",
    "        optimizer.zero_grad()\n",
    "        loss = td_loss_fn(agent, target_network, \n",
    "                          states, actions, rewards, next_states, done_flags,                  \n",
    "                          gamma=0.99,\n",
    "                          device=device)\n",
    "\n",
    "        loss.backward()\n",
    "        grad_norm = nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm)\n",
    "        optimizer.step()\n",
    "\n",
    "        if step % loss_freq == 0:\n",
    "            td_loss_history.append(loss.data.cpu().item())\n",
    "\n",
    "        if step % refresh_target_network_freq == 0:\n",
    "            # Load agent weights into target_network\n",
    "            target_network.load_state_dict(agent.state_dict())\n",
    "\n",
    "        if step % eval_freq == 0:\n",
    "            # eval the agent\n",
    "            mean_rw_history.append(evaluate(\n",
    "                make_env(ENV_NAME, seed=step), agent, n_games=3, greedy=True, t_max=1000)\n",
    "            )\n",
    "\n",
    "            clear_output(True)\n",
    "            print(\"buffer size = %i, epsilon = %.5f\" %\n",
    "                  (len(exp_replay), agent.epsilon))\n",
    "\n",
    "            plt.figure(figsize=[16, 5])\n",
    "            plt.subplot(1, 2, 1)\n",
    "            plt.title(\"Mean reward per episode\")\n",
    "            plt.plot(mean_rw_history)\n",
    "            plt.grid()\n",
    "\n",
    "            assert not np.isnan(td_loss_history[-1])\n",
    "            plt.subplot(1, 2, 2)\n",
    "            plt.title(\"TD loss history (smoothened)\")\n",
    "            plt.plot(smoothen(td_loss_history))\n",
    "            plt.grid()\n",
    "\n",
    "            plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "ENV_NAME = 'CartPole-v1'\n",
    "env = make_env(ENV_NAME, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAE/CAYAAAC+Q2VKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAACAhUlEQVR4nO3dd3hcV7X38e9W792SZcuW3HuJ7dhOcaL0kE5ooYYQCIRy4QIXCOXCBcIbLlx6KAECAVKBhIR024kcO8XdibvlJlmWLFm9ayTNfv+YkSLbkjWSZnRGM7/P8/iR5szMmXX2yHNmnb332sZai4iIiIiIiIgTIpwOQERERERERMKXklIRERERERFxjJJSERERERERcYySUhEREREREXGMklIRERERERFxjJJSERERERERcYySUpExxBhTZIz5uNNxDJUx5rfGmG/5eZ8fNcZs8Oc+RUTEN6P5GWyMKTDGWGNM1AD3f90Y84fRiGWojDGfNMb8zOk4ziZYvlsYY75jjPmb9/ccY8xeY0ys03HJ6FBSKo4zxhw1xriMMVmnbd/hPQkVOBSa+Im19lPW2u85HYeISDgyxjT3+ec2xrT1uf1BbzLQaYxp8v47YIz5lTEm1+nYfWGt/YG1dtCkarSTL2NMDPBN4Eej9ZqD6Zv4BTNrbSXwMnCH07HI6FBSKsHiCPD+nhvGmAVAvHPhvG2gK7MBfk1jjHHs/6cTxywiIoFhrU3q+QeUAtf32fag92GPWmuTgQzgncB4YOtYSUwDbZjn5RuBfdba44GIKQw8CHzS6SBkdCgplWDxV+AjfW7fCvyl7wOMMbHGmB8bY0qNMZXeIaHx3vvSjTFPG2NOGmPqvL/n9XlukTHme8aYV71XgV88vWe2z2MLjTFlxpivGmNOAH8yxkQYY75mjDlkjKkxxjxmjMnwPv4BY8yXvL9P9Pbuftp7e7oxptZ7MvMlxruNMa8CrcBUY8wVxph9xpgGY8yvADNQA3qvfv7DGPOo9xi3GWMW9bl/gjHmn97XP2KM+Y9+nvs3Y0wj8NF+9n+29u9ps68bY6q9vd8f7PPcPxtjvu/9Pct77PXetlnfc6I3xszxtkO9MWa3MeaGPvvINMY8ZYxpNMZsAqadFt9sY8xq7z73G2PeO1BbiYhI/6y1ndba3cD7gJPAl3x5njHmfGPMZu/5arMx5vw+933UGHPYe2460nN+8J4j13mfU22MeXSQl/mg9xxUbYz5Rp/99x32Gec9l9V4zyWbjWco6N3AKuBXxtND/Csf4j79vPwlY8zW0477S8aYfw0Q7zuAdX0e229sfV7r+8aY17zx/dt73nvQe97bbPqMHBsk7gne82WtMeagMeYT3u1XA18H3ud9jTf7xJpvBviOZIxZ6Y2r3hjzpjGm8LQ2GvD71SDPneJ9/5uMMauB07+XbcTzXSh/gPaVEKKkVILFG0CKNymJxHMyPH14yQ+BmcBiYDowEfhv730RwJ+AfGAy0Ab86rTnfwC4DcgGYoAvnyWe8XiuFufjGTryH8BNwMXABKAOuNf72HVAoff3i4HD3p8AFwHrrbXWxxg/7H29ZKAB+CeeoT9ZwCHggrPEDJ6rsn/3xv4Q8C9jTLQ36fs38CaedrsM+IIx5qrTnvsPIA3P1cnTna39wdNmWd7ttwL3GWNm9bOfLwFlwDggB88J0hpjor0xvojnPfoc8GCffdwLtAO5wMe8/wAwxiQCq73HnI2n1/3Xxph5A7aUiIgMyFrbDTyJJ5E7K+O5SPsM8AsgE/gJ8Iw3qUr0bn+Htyf2fGCH96nfw/OZnw7kAb8c5KUuBGbhOYf9tzFmTj+PuRVIBSZ5Y/kU0Gat/QawHvist4f4s2eLu8/++p6XfwFMOe11P4Tnwnp/FgD7B4utz/23eF9vIp4Lr6/j+d6QAewFvg1nb2/vfh7Gc56dALwb+IEx5jJr7fPAD/D0iidZa3svXDPAdyRjzETva33fG8eXgX8aY8b54bkPAVvxfHf4nrd9ellru4CDQN84JUQpKZVg0tNbegWwD+gd7mKMMcAngP+01tZaa5vwfLDeAmCtrbHW/tNa2+q9727eTgx7/Mlae8Ba2wY8hie5Gogb+La1tsP7+E8C37DWlllrO4DvAO82nmGu64BV3sTvIuB/eTt5vNh7v68x/tlau9v7QfwOYI+19h/W2k7gZ8CJQdpwa5/H/wSIA1YC5wLjrLXftda6rLWHgd/3tJ/X69baf1lr3d5j7jVY+/fxLW+brcNzIuqvt7ITT2KZ770i35O0rwSSgHu8Mb4EPA2833uh4l3Af1trW6y1u4AH+uzzOuCotfZP1toua+02PAn9uwdpLxERGVg5nmRiMNcCxdbav3o/gx/Gcx6/3nu/G5hvjIm31lZ4e2LBcz7IByZYa9uttYMVTvofa22btfZNPBdZ+0tWOvEkatOttd3W2q3W2sZhxg19zsve8/+jeBJRvBc+C/Ccq/qTBjQNIbY/WWsPWWsbgOeAQ9baNd7vBH8HzhksbmPMJDzJ+1e9bboD+AOeZPdsBvqO9CHgWWvts97vB6uBLcA1I3muMWYynu8mPd8bXsFzYfp0Td52lBCnpFSCyV/xXG37KKcN3cXTq5aAZ35LvTGmHnjeux1jTIIx5nfGmBLjGX76CpDmTWZ69E3oWvEkQAM5aa1t73M7H3iiz2vvBbqBHGvtIaAZz4fwKjwnp3JvD19vUupjjMf6/D6h721v4tb3/v70fbybt6+U5gMTeuL3HsPX8fRU9vfapztr+3vVWWtb+twu8b726X6E58rni8YznOtr3u0TgGPeuPvuY6L3daJOi7Gkz+/5wIrTju+DeHpvRURkeCYCtT48bgKnfibjvT3Re154H55ewQpjzDPGmNnex3wFz7SUTcYzZeNjnJ0v5/G/Ai8Ajxhjyo0x/+sdiTOkuPvcPv3c+ADwAe/F2g8Dj3mT1f7U4elh9TW2yj6/t/Vzu+d4zxb3BKDn4vFAx9Sfgdo2H3jPaefXC/FcXB7JcyfQ//eG0yUD9YPELiFASakEDWttCZ6CR9cAj592dzWeD+R51to0779U6ynaAJ4hobOAFdbaFDw9lnCWOZiDhXPa7WN4hh6l9fkXZ98uXrAOT69cjHfbOjy9vum8PUzJlxj7vm4FniE+ngd5ToCTOLu+j4/AMxyq3Bv/kdPiT7bW9r3Sefox9zVY+wOke4dp9Zjsfe1TWGubrLVfstZOxXM1+ovGmMu8j51kTi0kMRlPj/lJoOu045/c5/djwLrTji/JWnvnWY5JREQG4P0svh7PkNfBlONJQPrq+fzGWvuCtfYKPMnIPjwjdbDWnrDWfsJaOwHPiKRfG2OmjyRu7wic/7HWzsUzVPg63q5Zcfp57qxx9/cca+0bgAvPRegPMPDQXYC38Ex78SW2oThb3OVAhjEmuZ/74Ozn+v4cA/562vk10Vp7zwifW0H/3xt6eUejTcfTKy4hTkmpBJvbgUtPu3LW0+v3e+Cnxphs6C0q1DMnMhlP0lTvnWvxbT/H9Vvg7p7J9saYccaYG/vcvw74LJ7eT4AiPHMiN1jPvJzhxPgMMM8Yc7P3g/k/GLznb2mfx38B6MAzX3cT0Gg8xZvijTGRxpj5xphzBz1yfGr/Hv9jjIkxxqzCc7L9++n7MsZcZzzFLQzQiKfHuRtPQYMW4CveebCFeL4QPeJtw8eB73h7nOdy6tyTp4GZxpgPe58bbYw5d4D5RiIiMgDv5+ccPPMSx+OZCjKYZ/F8Bn/AGBNljHkfMBd42niKDN3gTT468Iws6va+1nvM2wX/6vAkTN397H8o8V9ijFngHYXUiGfIbM8+K4GpvsQ9yMv8BU9NiK5Bhhw/S59pOoPENhQDxm2tPQa8Bvw/4ymstBDPd6ueWhGVQIHxvZLw3/AMC77K+90hzniKG+YN+syzPNfbEbGFt783XMipw6YBluOZmtNfD6qEGCWlElS8cym2DHD3V/EM+3zDO/x1DZ6eR/DMt4zH06P3Bp6hpf70c+ApPENOm7yvsaLP/evwJJ09SekGPMNdX+nzmCHFaK2tBt4D3APUADOAVweJ80k8w6Tq8Awrutl7ZbYbz4f9Yjy90dV45pikDrK/vs7W/uAZvlOH5yrtg8CnrLX7+tnPDO9zm/EUcfi1tbbIWusCbsAzl7Ya+DXwkT77+CyeIUEngD/jKf4AeHpfgSvxzHEt9z7mh4AW3RYR8c37jDHNeIZKPoXnvLPUWnvGiJfTWWtr8FyI/JL3eV8BrvOexyK828vxDAW+GPi096nnAhu9r/sU8Hlr7ZERHsd4PEX7GvFMtVnH24UTf46nHkSdMeYXg8R9Nn8F5nP2XlLwzJGcbYzpmcpytth85kPc78cz17UceAJPjYzV3vt6LhbXGGO2+fBax/AUQvw6nlFLx4D/woccwofnfgDPd6laPBfqT5+69UE8nQISBoxnmpqIjHXGmO/gKZ7wIQdeuxD4m7XWlyunIiIiY5bxLIdWBSyx1hYP8tg7gLnW2i+MRmyhwjsqax1wzmk1PiRERTkdgIiIiIjIGHInsHmwhBTAWnvfKMQTcqy1VYCm4IQRJaUiIiIiIj4wxhzFU6DwJmcjEQktGr4rIiIiIiIijlGhIxEREREREXGMklIRERERERFxTFDMKc3KyrIFBQV+2VdLSwuJiYmDPzCEhOMxQ3gedzgeM4TncYfjMYP/jnvr1q3V1tpxfggpbOncPLrURr5RO/lG7TQ4tZFv/NlOZzs3B0VSWlBQwJYtAy1NOTRFRUUUFhb6ZV9jRTgeM4TncYfjMUN4Hnc4HjP477iNMVpsfYR0bh5daiPfqJ18o3YanNrIN/5sp7OdmzV8V0RERERERByjpFREREREREQco6RUREREREREHKOkVERERERERByjpFREREREREQco6RUREREREREHKOkVERERERERByjpFREREREREQco6RUREREREREHKOkNMgcrGqmtKbV6TBEREREgs6h+m7qW11OhyEifqakNMh84dHtfP2JnU6HISIiIhJUXF1uvvdGO7f9ebPToYiIn0U5HYC8zVrLoaoWEmPbnQ5FREREJKhUNLQBsL203tlARMTv1FMaRE42ddDW2U11s4vaFg1NEREREelRVudJSiOMw4GIiN8pKQ0iR/vMJT1Q2eRgJCIiIiLB5Vit53tSdKS+voqEGv2vDiJHa1p6fy9WUioiIiLSq6en1KinVCTkKCkNIqU1rURGGJJiozhQ2ex0OCIiIiJBwVrLvhOeC/btnW6aO7ocjkhE/ElJaRA5WtPCpPR4ZuYkafiuiIiIiNe/dhxnzd5KYrzfXL/5xE6qGlUYUiRUKCkNIiU1rUzOTGRmTjLFVeopFREREQE4VNVChIGvLY8D4F87yrWEnkgIUVIaJKy1HK1poSAzgRk5ydS2uKhu7nA6LBERERHHNbV3khwXzdS0SF75r0u4al6OpjqJhBAlpUGirrWTpvYu8jMTmZmTBKgCr4iIiAhAY3sXKfFRAEzOTGB6dhLl9W10u63DkYmIPygpDRIl3sq7BZkJzMxJBqBYVwBFRGQIjDGzjDE7+vxrNMZ8wRiTYYxZbYwp9v5MdzpWkaFoau8kOTa69/ak9AS63JaKhjYHoxIRf1FSGiRKvGuU5mcmkJ0cS3JclHpKRURkSKy1+621i621i4GlQCvwBPA1YK21dgaw1ntbZMxobHu7pxRgUkYCAMdq305K3W7LN57YySU/LuK6X67nWG0rbvWkiowJPiWlxpijxpid3quuW7zbBrzqaoy5yxhz0Biz3xhzVaCCDyVHa1owBvLSEzDGeIodqadURESG7zLgkLW2BLgReMC7/QHgJqeCEhmORu+c0h6T0j1J6ft//wa1LS6OVLfwjX/t4sGNpUzJSqS0ppV3/vo15n77eZ7ccdypsEXER0PpKb3Ee/V1mfd2v1ddjTFzgVuAecDVwK+NMZF+jDkkldS0MiE1nrhoT1PNzEniQFUT1uoKn4iIDMstwMPe33OstRUA3p/ZjkUlMgxN7V2k9ElKJ6TFsTAvFYAl31vNJT8u4pHNpdx+4RT+eOsyPrFqKtXNHbR3uvn8Izu0rqlIkIsa/CEDuhEo9P7+AFAEfNW7/RFrbQdwxBhzEFgOvD6C1wp5R2tayM9M6L09IzuZh1uPcbK5g+zkOAcjExGRscYYEwPcANw1xOfdAdwBkJOTQ1FRkV/iaW5u9tu+QpXa6Oxqm9torDlBc0Jnbzt9cT78JSKKV493cf3UaFbkRjEuoYp166pIaOo+5fk/+fvLXJQX3c+eQ5P+nganNvLNaLWTr0mpBV40xljgd9ba+zjtqqsxpueq60TgjT7PLfNuk7MorWnlynnje2/3FDs6WNmspFRERIbqHcA2a22l93alMSbXe77OBar6e5L3/H4fwLJly2xhYaFfgikqKsJf+wpVaqOBud2W9heeZc70KSRFl5/SThddZHF1u3tHmvVY5bZ8741nee+yPLaU1LGnNZb/LjxvlCN3jv6eBqc28s1otZOvSekF1tpyb+K52hiz7yyPNf1sO2MMqq7Gvq2101LT4qK7voKiohoA6tvdADzz6nZcZWe/sjcWj9kfwvG4w/GYITyPOxyPGcL3uAPg/bw9dBfgKeBW4B7vzyedCErEV8/urGB8ahxLJqfT7OrCWkiJi4JTO0CJiDDERZw5SywywrD3u1cTExXB/z6/j/tfPUKrq4uEmCjW7KnkRGM7V87LGfaF/7V7K5mdm8LEtPhhPV9ETuVTUmqtLff+rDLGPIFnOO5AV13LgEl9np4HlPezT12N9dp1vAHWbuDS5QsonJ8LgLWWb29cjU0ZT2HhgrM+fywesz+E43GH4zFDeB53OB4zhO9x+5MxJgG4Avhkn833AI8ZY24HSoH3OBGbiC/cbsunH9wGwLULc7l4xjgAz5zSFt/3Ex/jSVYvmJ7F7145zEMbS5mZk8zH/7IFgPteOcwrX7lkyPGV1LRw+wOefWz71hVkJMYMeR8icqpBCx0ZYxKNMck9vwNXArt4+6ornHrV9SngFmNMrDFmCjAD2OTvwEPJUe8apfmZib3bPBV4kyjWsjAiIjIE1tpWa22mtbahz7Yaa+1l1toZ3p+1TsYocjYlta29v796sJqv/PMtAFLihzcn9NyCDBJjIvn+M3v5yP2er6QXzRxHRUPbsApKHql+OzN+s6x+WDGJyKl86SnNAZ4wxvQ8/iFr7fPGmM30c9XVWrvbGPMYsAfoAj5jre3uf9cCp65R2teMnGSeeasCay3e9hcREREJabvLPddTnv7chUzPTmLjkVoOnGji4pnj2Fh9thlk/YuPiWT1Fy+mtLaVzz28naWT01k4KZVXDpyko+vM+aiDKe2TNO+raOKSWSpmLTJSgyal1trDwKJ+ttfgWQOtv+fcDdw94ujCRElNC9nJsSTEnPp2zMxO4qG2Tk42dZCdomJHIiIiErq+/Pc3OV7XxuuHa4gwMCMnidioSC6eOY6LZ44b0b4npMUzIS2e1792KW4Lj245BkBjW+eQk9KSmlbioyNJT4hm34nGEcUlIh4jWRJG/ORoTesZvaTwdgXeA5XNSkpFREQkpP1ja1nv759YNZXYKP8vcx8V6Zm5lhLn+Qrc2N5FdsrAj69sbGdPRSMbD9eyeFIaW47W8scNR5iRnUR+ZgJbS+ro6nb37ldEhkdJaRAoqWlh1YwzrwDO6E1Km7hwRtZohyUiIiISECca2rnhVxv46+0rmDU++ZS5nb98/zlcv2hCQF8/Jc4zP7WpvXPAx3S7LZf/3zqaOrrOuC87JZZ3L53Ep/62lUc2H+NDK/MDFqtIONBlHYe1ubqpbOygoJ+e0qykGNIToimuUrEjERERCR2vHqymqqmDn64+AHh6LAG+ee2cgCekAMnentKm9jMTzh5N7Z00dXRxbkE6H/YmncmxUdz/0WV898b5XDUvh+zkWHYcqw94vCKhTkmpw3omy/etvNvDGMOM7GQOVDaPdlgiIiIiAZOW4Omp3HncU9SoprkDgKyk2FF5/eTentKBk9L6Vk8v6vuXT2b5lAwAYqMjuHR2DtPGJWGMITkuijaX6nmKjJSSUoe9vRzMmT2l4Jnkf6CyaVgly0VERESCUUeXG4Dj9Z5lWaqbXQBkJo3Omp9v95QOPHy3vs1zX2p8NAsmpgIwdVzSKY9JiImi1TVwYisivtGcUoeV9CSlGWf2lIKn2FFTexeVjR2MT1WxIxERERn7Orre7l38x9Yy/usfnrVIMxNHq6d08OG7Dd6kNC0hmvzMBO65eQGXzj51+Zf4mEha1FMqMmLqKXXY0ZpW0hOiSU3of0HoGTmeK3IHKjWvVEREREJDR6e79/eehBQgK3l0ekoTY6KIMIP0lLZ6em9T42MwxnDL8slnrIaQEBOp4bsifqCk1GElNS39zift0bMsTHGV5pWKiIhIaOgZvnt6oceMhNFJSiMiDEmxUb0FlvrT2Gf47kASNXxXxC80fNdhJTWtLMtPH/D+rKRYMhJjKFZPqYiIiISI9k5P7+LDd6wkOS6ae18+yAu7Tozqep/JcdE0DtBT2ubqZktJHXD2pDRePaUifqGeUgd1dHVTXt/G5LP0lALMyE7S8F0REREJGT09peOSYkmKjeKrV8/mpS8XjmoM2SmxlNe39Xvf//x7N0/uKAcgJmrgr8sJMZG0diopFRkpJaUOKqtrw23PHLpyupk5yRRXNqsCr4iIiISEjq5uoiLMqPaMnm5mtuf7VX/2nfCtMyA+JpLWDiWlIiOlpNRBvZV3B+kpnZmTRFNHFyca20cjLBEREZGA6uh0E3uWHsjRMCMniZoWF9XeNVL7GqzDoEdCdBSubjdd3e7BHywiA1JS6qCj1a3A4B98M7zFjg4McDVPREREZCxp7+omNjrS0Rhmje/5fnVmr2izt/fz9CVgTpcY6zkGDeEVGRklpQ4qrW0lKTaKjMSzV5rrrcCreaUiIiISAoKhp3RObgoRBtburaKz201nn97OxrZOVk7N4P6PnnvWfcTHeJJSFTsSGRlV33XQ0ZoW8jMTMMac9XEZiTFkJcWo2JGIiIiEhI4u55PSrKRYbl6Sx1/fKOHfb5ZT1dTBxLR41nzxYurbXEzNShp0HwnepLRVSanIiKin1EElNa0UDDKftMeM7GQN3xUREZGQ0NHVTZzDw3cBPrhiMq4uN1VNnnmlx+vbOFzdTH1rJ2kJAy8F0yM+2tO/09KhtUpFRkJJqUO6ut0cq20l38eJ9DNykjhYpQq8IiIiMvYFQ08pwIKJqb2///R9iwBPzY+Gts6zrk/ao2dOaZvmlIqMiPOfBmGqvL6dLrf1vac0J5nmji7KG1SBV0RERMa29s5uYqOc7ymNiowg3ttje/mcHAD2n2iko8tNqg89pRq+K+IfmlPqkJJaz3Iwk33sKZ2Z7ZnXcKCyiYlp8QGLS0RERCTQOrrcJMUGx9fQNV+6mNpmF8lx0YxLjmVHWQMAafFnL0QJkBDjOYaj1S2cPy2TaAfXXRUZy/Q/xyFHa3qWg/Gtp1QVeEVERCRUBEP13R4T0+JZkOcZxjslM5FNR2oAfBq+Oz07idnjk/n2U7u57U+bAxqnSCgLjk+DMFRS3UJcdATZybE+PT49MYaspFgVOxIREZExYf+JJn65tphdxxvOuK8jCNYp7c9Hzs9nwcRUZuYkMX9iyqCPj46M4PcfWQbA5qO1qv0hMkzBMW4iDB2taSU/I5GIiLMvB9PXzJwkiquUlIqIiEhw23+iiet/tQFXl5v1B6t57JPnAbC3opGn3yrn0MkWFk1KczbIfly3cALXLZwwpOdMykjgW9fN5XtP76GutXPQ9edF5ExKSh1SWtvi89DdHjNzkvn7lmNYawdd21RkNPzkxf28eqiGf955vtOhiIhIEHmrrB5Xl5ur5uXwwu5KfvTCPt44XMvWkrrex0RHhM6AvQJvjZCjNS1KSkWGIXQ+DcYQt9tSUuP7cjA9ZuQk0eLq5nh9W4AiExmaF/dUsrWkjoPqwRcJGsaYNGPMP4wx+4wxe40x5xljMowxq40xxd6f6U7HKaGtpxrth1bmA3Dvy4eobu7gPy6dzpevnAnAoZOhc+7I93Y0lNS0OByJyNikpNQBlU3tdHS5ez/AfPV2saPQ+RCXsaupvZP93sJbL+454XA0ItLHz4HnrbWzgUXAXuBrwFpr7Qxgrfe2SMD0JKXL8jN46BMr+NvtKyj6ciFfvHIW7102CQittT0nZcQTYeC7/97Dxx/YQrdbc0tFhkJJqQOOVg+t8m6PmdmepPSAKvBKENhxrB5rITYqgtV7Kp0OR0QAY0wKcBHwRwBrrctaWw/cCDzgfdgDwE1OxCfho9XVhTEQFx3B+dOyuHBGVu/Uo+yUOH78nkX86gNLHI7Sf2KjIvmfG+axeFIaa/ZW8vqhGqdDEhlTlJQ6oGdox1CH76YmRJOdrAq8Ehy2ldRjDNx6fgHbS+upamx3OiQRganASeBPxpjtxpg/GGMSgRxrbQWA92e2k0FK6Gvp6CYxJmrAGhjvXprHlKyhXZwPdh8+r4DffGgpybFR/HbdIRpaO50OSWTMUKEjB5TUthIdaZiQFj/k587MSaa4Sj2l4rxtpXXMyE7iXUvyuO+Vw6zZW8UHVkx2OiyRcBcFLAE+Z63daIz5OUMYqmuMuQO4AyAnJ4eioiK/BNXc3Oy3fYWqUGujgyUdRNHt92MaC+103ZQIHtlXzap7VnPDtGhWl3RSOCmaaWkRxEcZJiUHvk9oLLST09RGvhmtdlJS6oCSmhYmpScQOYTlYHpMz07i0c3HcLvtkJaTEfEnt9uyvbSOaxbkMjMnickZCby454SSUhHnlQFl1tqN3tv/wJOUVhpjcq21FcaYXKCqvydba+8D7gNYtmyZLSws9EtQRUVF+GtfoSrU2uifFdtJb2/w+zGNhXYqBD54vIGvP7GTv+31rNH66H5X7/1/vX05q2aMC2gMY6GdnKY28s1otZOSUgccrR565d0eM3OSaev0VOCdlDG8fYiM1OHqZhrbu1iSn44xhivn5vCX10to7ugiKVYfKyJOsdaeMMYcM8bMstbuBy4D9nj/3Qrc4/35pINhShho7egiISbS6TAcM39iKk98+gL+ubWMrOQYqho7aHV1892n9/DyvpMBT0pFxhp9exxl1lpKalpYPiVjWM+fmZMEeIodKSkVp2wrqQdgyWTPqhJXzM3hDxuOsG7/Sa5dmOtgZCICfA540BgTAxwGbsNTQ+IxY8ztQCnwHgfjkzDQ4uoiMSa8v2ZGRhjee+6kU7Y9u7OCN8vqnQlIJIip0NEoq2520eLq7l1keahm5PRU4A2dYkc7yxq46qevUKlCOWPGttI6UuOjmeotUrE0P52MxBhWa2kYEcdZa3dYa5dZaxdaa2+y1tZZa2ustZdZa2d4f9Y6HaeEtjZXNwmx4dtTOpCFeWnsLm+gq9vtdCgiQUVJ6Sgrre2pvDu8inOp8dHkpMRSHELLwvxszQH2VzZRtL/fKU4ShLaV1nHO5LTeec1RkRFcOjubl/ZV0akTrYhI2GtxdYd9T2l/5k1Iob3TTUltq9OhiAQVJaWjrGeN0uHOKQXPvNIDIVKBd/+JJtbu8ySjGw/rwv1Y0NjeSXFVc+/Q3R5Xzs2hsb2LTUf0PoqIhLtwn1M6kLx0z8oLx+vaHI5EJLgoKR1lJTUtRBjISx9+UjojO5mDVc243daPkTnjd68cIj46kvOnZbJRycyYsKO0Hms5IyldNWMccdERvLhbQ3hFRMJdi6ubRBW+O0Oetx7I8XolpSJ9KSkdZUdrWpmYHk9M1PCbfmZOEu2dbsrG+FW24/VtPLWjnFuWT+KqeeM5Xt/GMQ1nCXpbS+owBhZNSj1le3xMJKtmjGP1nkqsHfsXTEREZPhaXV3Eq6f0DDnJsURGGPWUipxGSekoK6lpIT9jePNJe7xd7GhsD+H9w/rDAHx81VRWTPVUI1ZvqX8crGrie0/v4eqfvcKhk/4tirWttI5ZOckkx0Wfcd8Vc3Mob2hnd3mjX19TRETGDleXm85uS6KS0jNERUYwPiWOsjpdhBfpS0npKCupHf4apT1m9CwLM4bnlda1uHhk0zFuWDyBiWnxzMxOJi0hmo2Ha5wObcxqc3Xzz61lvPs3r3H5T17hL68fZX9lE09uP+6313C7LTuO1XPOaUN3e1w2O5sIg4bwioiEsfo2FwAJKnTUr4np8Rq+K3Ian5NSY0ykMWa7MeZp7+0MY8xqY0yx92d6n8feZYw5aIzZb4y5KhCBj0X1rS7qWzspGGbl3R4pcdHkpsZRPIaXhfnL6yW0dXbzqYunARARYVhekKGe0mHYW9HIt5/cxfIfrOFLf3+TmhYXX79mNq/fdRnL8tNZs9d/VY0Pnmymqb2LJZPT+r0/MymWZfkZvLin0m+vKSIiY4e1lqL9JwFYVtD/BcxwN29CCltL6li7V+dKkR5DuYT1eWAvkOK9/TVgrbX2HmPM17y3v2qMmQvcAswDJgBrjDEzrbXdfox7TCqpGXnl3R4zcpLH7PDdVlcXf37tCJfNzmamdygywIqpmby4p5KKhjZyU+MdjDD4tXR08fRb5Ty06RhvHqsnJiqCd8wfz/uXT2bFlAyM8SzVctmcHO55bh/l9W1MSBt5m24rqQNgSf7AXzSunJfD95/Zy7HaViZljPxvXURExoZ9Jxp5929ep7mji8kZCSyYmDr4k8LQl6+cxdaSOj7z0Dae+uyFp3wXEglXPvWUGmPygGuBP/TZfCPwgPf3B4Cb+mx/xFrbYa09AhwElvsl2jHuaI1njdKCrJH1lALMzE7iYFUz3WOwAu9jm49R19rJnYXTTtm+Yop3XqmWhhnQ0YZu7np8J8vvXsNX/7mT1o4u/vu6uWy86zJ+fss5rJya2ZuQAlw+Jxugd9mdkdpWWkdaQjRTz/I3fMXcHAD1loqIhJnNR+to7ugC4FMXTzvlfCRvS4yN4o+3nkukMfym6JDT4YgEBV+H7/4M+Arg7rMtx1pbAeD9me3dPhE41udxZd5tYa/U21M62Q+9RzNykujoco+5arWd3W5+v/4Iy/LTWVaQccp9c3JTSI6LYuMRzSvtz0MbS/nO6+08sb2MdyzI5Z93nseL/3kRH7twCumJMf0+Z9q4JPIzE/w2RGhbaT1LJqef9YtGfmYis3KSNa9URCTMVHjnSf74PYv4wIrJDkcT3MYlx/LupXn8+81y2lxhP5hQZPDhu8aY64Aqa+1WY0yhD/vs79vqGd15xpg7gDsAcnJyKCoq8mHXg2tubvbbvvztjd0dpMca3nh1/Yj31VTv+QB7fO3rzExsD9pjPt1r5V0cr+/g3VPd/cY8Ndny8q4yijIG7y0N5vc6EB7c3EZOvOW/z48jMbqOpiN1rDsy+PNmJbl4qbiVF9a8TGzU8K9at3RaDla1sjC1Y9B2n5nk4ulDTTz94sskxYz8Snm4vdcQnscM4XvcIqHgWF0b+ZkJvHtpntOhjAkzxyfT5bY0tndq+RwJe77MKb0AuMEYcw0QB6QYY/4GVBpjcq21FcaYXKBnfGAZMKnP8/OA8tN3aq29D7gPYNmyZbawsHD4R9FHUVER/tqXv/1q72vMnGAoLDxvxPta2t7J9994kdjsApJMWdAec1/WWu75+XpmZEfz+XdfRETEmclKccRh7n52L3OXrCQ7Je6s+wvm99rfOrvd3Ln2RS7IjebaKy4Z0nOj86p58Q8bMblzKJw3ftgxFO2vAjbz7ouXcP70rLM+NmN6Pf/+1au0Z87gOj98OQmn97pHOB4zhO9xi4SCY7WtTEpXLQFfJXgT0Vb1lIoMPnzXWnuXtTbPWluAp4DRS9baDwFPAbd6H3Yr8KT396eAW4wxscaYKcAMYJPfIx+Djta0jrjybo/kuGgmpMaNqWJHRftPsu9EE5+6eFq/CSmg9UoHsOt4A22d3czKGPqV1HMLMkiOjWLtCKvwbiutJ8LAoklpgz52wcRUxqfEsXqPhvCKiIQLFbgbmp4lc1q883BFwtlI1im9B7jCGFMMXOG9jbV2N/AYsAd4HviMKu9Cc0cX1c0d5Gf578PaU4F37CwL85t1h5iQGscNiycM+Ji5uSkkxWpe6ek2eZP0melDT0pjoiK4aNY41u6rwj2CwljbSuqYNT6FxNjBB1gYY7hibg6vHKimvTPs//uLiIS8lo4ualpcTMpQ9Xxf9fSUtuk8KTK0pNRaW2Stvc77e4219jJr7Qzvz9o+j7vbWjvNWjvLWvucv4Mei3qKHOVn+KenFGBmThKHTjbjtsFfgXdrSR2bjtRy+6qpREcO/GcXFRnBsoJ0VeA9zaYjtUwdl0hq7PDmZ14+J5vq5g7eOt4wrOd3uy07jtUPuD5pf66cl0NbZzcbiquH9ZoiIjJ2lNV5ihxp+K7vNHxX5G0j6SmVISjxLgfjjzVKe8zIScbV5aaqNfiT0t+uO0RaQjS3nDtp0MeumJJJcVUz1c0doxBZ8Ot2WzYdre1dMmc4CmdmE2HgpWFW4S2uaqK5o4slk31fCH3FlEySY6N4UUN4RURCXmmt/1YYCBfx0Z6RR60aviuipHS0HO3pKfVjUtqz2PLxZvcgj3zbyaYONhRXj+r6pgermli9p5KPnFfg09DPnnmlmzSvFID9J5poau9i+QiS0vTEGJbmp7NmmPNKt5XUA7Ak3/ekNCYqgktmZ7N2b9WYXE9XREQGZ72jtXqWqNOcUt8lxqqnVKSHktJRUlLTQlZSDMlx0X7b54zsJODsSWmbq5ui/VXc/cwerv7ZK5x79xo+9MeNPL9r9HqvfrvuMHHREXz0/AKfHr9gYioJMZFsPKx5pUDv/NrlUzJHtJ/L5uSwp6KRcu86ckOxrbSOjMQYCoZ4UeWKuTnUtLjYVlo35NcUEZHgVt3cweU/WceXHnuTl/ZVkRgTSXqC/77nhLqeZWBaNadUxKclYcQPjta0+H1IS2JsFBPT4ilvdvVu63Zbdh1vYMPBajYUV7O1pA5Xt5uYyAiW5qfzX1fN4lcvHWTz0VquXZjr13j6U9HQxpM7jvPBFflkJMb49Jxob6yqwOux6UgtE9PimZgWT/EI9nP5nGzueW4fa/dV8eGV+UN67rbSOs6ZlIYxQ5vTWjhrHNGRhtV7Kjm3YPg9vSIi4jxrLWV1bWQmxfDPbcf5w/rDlNS0cuikZ4pSfHTkkM8T4ayn+q6G74ooKR01pTWtrJw6sp6u/szMSWLvsWoe3FjCqwerefVgDQ1tnQDMyU3h1vPzuXDGOJYXZPReketJVkfDH9cfwW3h9gunDOl5K6Zk8OMXD1DX4iLdx2Q2FFlr2XSklotnjhvxvqaNSyI/M4G1eyuHlJTWt7o4fLKFdy0Z+nqjyXHRnDctixd2n+Cud8zWlxURkTHs4U3H+PoTO3tvL8xL5f6PLqO+tZPNR+uYNyHFwejGnvhoDd8V6aGkdBS0d3ZT3tBOvp/WKO1r1vgUXt5/km88sYvc1DiunJvDhTOyOH9aFuOSY/t9ztL8dH6z7hAtHV0+zfEcrvpWFw9vKuX6hblDnmOywpvAbzpay1XzxgcivDHh0MkWalpcI5pP2sMYw6Wzs3lwYymtrq7eK7SD2V5aDzCkIkd9XTk3h2/+axfFVc2986BFRGTseXLHccBzQfx7N85n+ZSM3ouNNw/jwmW4i4wwxEVHaEkYEZSUjoqeyf8FflyjtMfHLizAVXOMD1x5HtPGJfrUE7U0P51ut+XNsnrOn5bl95h6/PX1Elpc3Xzy4mlDfu7CvFRioyLYeDi8k9KeYk/+SEoBLp+Tw59ePcqG4mqu9LFdt5XWERlhWDQpdViveYU3KV29p1JJqYjIGLS3opG/vF7CxiO1fOriaXz16lka+eInCTFRtGj4rogKHY2Gtyvv+r+nNDs5jovyopmeneTzCeIc71qT2wI4hLe9s5s/v3aUS2aNY07u0IfzxEZFsmRyem+Rn3C16UgNWUmxTMnyz9/OuQUZJMdGsXYIVXi3ldYxe3yyzz2rp8tJiWPRpDRe3K2lYURExqL7XjnMw5tKuWjmOG67oEAJqR/FR0fSpuG7IkpKR0PvGqVBUiY9LSGG6dlJAZ1X+vctx6hpcfGpYfSS9lgxNYM9FY29c2TDjbWWjUc865P66wtATFQEF80ax9p9Vbh9WKal223ZUVo/7KG7Pa6cm8ObZQ2caGgf0X5ERGT0lda2snJqBn/52HJyUuKcDiekJMREak6pCEpKR0VJTSspcVGkBVGZ9KWT09lWWu9TYjJUXd1ufvfKYc6ZnDaiYacrpmRiLWw5Gp5VeMvq2qhoaO9dt9VfLp+TTXVzB28dbxj0sftPNNHi6mZJftqIXvPKuTkArN5bOaL9iIjI6Cura2VSenBcWA81CbFRtLg0fFdESekoOFrTQkGWb/M9R8vS/HQa2jo5XN3s930/s7OCsro27rx42oiO+ZzJacRERoTt0jD+nk/ao3BmNhEGXvIhQexZX3SkPaXTs5MoyExg9R4lpSKBZow5aozZaYzZYYzZ4t2WYYxZbYwp9v4c2X9qCRvtnd1UNnaQp6Q0IBKi1VMqAkpKR0VJTWtA5pOOxJJ8z/eRQAzh/df240zKiOfyOTkj2k9cdCSLJ6Wx8XDwzys92dTB9b/c4NdYNx2pJTU+mpnZ/i0OlJ4Yw9L8dNb4MK90W2kdmYkxI15j1xjDlfPG8/qhahrbw3M4tsgou8Rau9hau8x7+2vAWmvtDGCt97bIoA5UNgEwKSPe4UhC07TsRLaV1vH5R7bzzX/t5MIfvsSdf9tKTXOH06GJjColpQHW2e3meH1b0Mwn7TFtXCJpCdF+T0o7urp543Atl8zKJiJi5D3DK6ZmsKu8keYgr0z3i7XF7DzewP2vHvHbPjcdreXcggy/tOPpLpuTw56KRsrr2876uO2l9ZwzOd0vvfxXzM2hs9uybv/JEe9LRIbsRuAB7+8PADc5F4qMFcdqW7nhV68CqKc0QL5xzVzev3wyT+4o529vlJKVFMtL+6q45hfrue+VQ3QHYJqVSDBSUhpgx+va6HZb8jOD68PcGMPSyel+T0q3ldTT1tnNhdP9s9TMiimZdLttUM8rPXSymYc2lZIUG8VL+6qob3WNeJ9Vje0cqW5hhZ+H7va4fE42AGv3DdxbWtvi4kh1y4jnk/ZYMjmdzMQYXtQQXpFAs8CLxpitxpg7vNtyrLUVAN6f2Y5FJ2PGr146CMCls7NZmDe8ZcHk7OJjIvnBOxfw/BdW8b0b5/H4nefz59uWMzkjgR88u4+P3L+Rrm6302GKBJzWKQ2wo97KuwV+WtLDn5bkp7N2XxV1LS7SE2P8ss8NB08SGWFYOS3TL/tbkp9GVIRh45FaCmcF53eoHz2/n7ioCO794BJuvX8T/36rgg+vzB/RPjcdDcx80h7TxiUxOSOBtXsrB4x1u3c+6dIRziftERlhuGxONs/tPIGry01MlK6JiQTIBdbacmNMNrDaGLPP1yd6k9g7AHJycigqKvJLQM3NzX7bV6gKxjbasK+Vc7Ij+UhBC2+8ut7pcIDgbCd/mQS88spRAD49y/KvyGiePFjDI88WkZc8tHNmKLeTv6iNfDNa7aSkNMBKetcoDa6eUvAUOwLYfqyOS2ePbP5nj/XF1ZwzKY2UOP9UGk6IiWJhXmrQzivdWlLL87tP8MUrZnLRjCxmj0/m8W1lI09Kj9SSEBPJvAlDX+PVF8Z4EsQHN5bS6urqdw3SbaV1REUYFual+e11r1mQy2NbyvjH1jI+sGKy3/YrIm+z1pZ7f1YZY54AlgOVxphca22FMSYX6HeYhLX2PuA+gGXLltnCwkK/xFRUVIS/9hWqgrGNzMaXmDIxg8LCxU6H0isY2ylQunIqefLQFhads5QFQ+ypDqd2Gi61kW9Gq53UVRFgR2taSIiJZFxSrNOhnGFRXhqREcZvQ3jrWlzsPN7AhTP8M3S3x4qpmbxV1kBrkJVMt9byg2f3MS45lo+vmoIxhneeM5HtpfUcqW4Z0b43HallaX46UZGB+y96+ZwcXF1uNhRX93v/tpJ65uSmEB8T6bfXvHjmOM4tSOcnq/cH/TxhkbHIGJNojEnu+R24EtgFPAXc6n3YrcCTzkQoY0mbq9uv5wAZmljviCJXt6rzSuhTUhpgJTWtTM5ICKrlYHrEe3vithz1T1L62qEarIVV/k5Kp2TQ5bZsK6n3635H6oXdJ9haUscXr5jZ29N40zkTiTDwxLayYe+3vtXFvhNNAZtP2uPcggySY6NY208V3q5uN2+W1bNkcppfX9MYwzeunUt1s4vfFh3y675FBIAcYIMx5k1gE/CMtfZ54B7gCmNMMXCF97bIWbW6uklQUuqYnmkuHZ2aUyqhT0lpgJXUtFAQZMvB9LVkcjpvltXT6YdJ9OuLT5IcG8UiPw73BFhWkEFkhGHjkeAZwtvZ7eaHz+9nenYS71ma17s9JyWOC6Zn8fj247iHWTFvs/ciwfIp/pmXO5CYqAgumjWOtfuqzoh1f2UTra7u3qWD/GnxpDRuXDyB368/PGj1XxEZGmvtYWvtIu+/edbau73ba6y1l1lrZ3h/Bm/1OAkKbrelrbOb+GglpU7pTUpV6EjCgJLSAOp2W47VtpGfFXzzSXsszU+nvdPN3orGEe3HWsv64mrOm5bp9yGnSbFRzJ+QwsbDwfMd6pFNpRypbuGud8w+43hvXjKRsro2tgxzWPSmIzXEREWMSqXDy2ZnU93cwc7jDads3+aNfYmfihyd7r+umoUFfvTC/oDsX0RERqa9yzNkNL6fmgMyOmK83y9cXUpKJfQpKQ2gk00duLrdTAritb16ih2NdF7pkeoWjte3+X3obo8VUzPZcaye9k7n51U0d3TxszXFrJiSwaWzz6wIfNW88STERPL4MIfwbjpSy+JJacSNwtXpS2ZlE2Fg7d5Tl2nZVlpPVlIseemBWSw9Lz2B2y+cwhPbj/NWWX1AXiOQtpfWqUS/iIS0VpfnfKvhu87pnVOqpFTCgJLSAKpu7gAgKwiLHPWYkBZPbmrciJPSDQc9xXJWzRjnj7DOsGJKBq5uN9tL6wOy/6G4b90halpc3HXNnH7nCifERHH1/PE8s7NiyEl0c0cXu8obAz6ftEd6YgxL89NZc9q80m2ldSyZnBbQudCfLpxGZmIM339mL9aOncXBNx2p5Z2/fo2/vVHidCgiIgHT5urpKVVS6pQYJaUSRpSUBlBNiwuArCT/rAEaKEvy03uHaw7X+uJq8tLjA7b0zbKCDIzB8XmllY3t/H79Ea5bmMviSWkDPu5dS/Joau9izWk9kIPZVlJHt9sGbH3S/lw2J4c9FY298zurmzsoqWkNyHzSvpLjovnCFTPZdKSWF/cMrZ2c9McNhwH491sVDkciIhI4bZ3qKXVabJSn7TuUlEoYUFIaQLUtnp7SzCDuKQVYlp9OeUP7sIvOdHa7ef1QDatmjAtYz1pqfDRzc52fV/qzNQfocrv5ylWzz/q4lVMzyU2N4/Ftx4e0/41HaoiMMAGby9mfy7xDkNfu8/SW9vRGj0YM7z93EtOzk7jnuX1j4kpwaU0rL+6pZFxyLFtL6lSoSURClobvOu/tnlLnpy6JBJqS0gCqafb0lGYkBndPac+80m2lw+stffNYPc0dXQGbT9pjxZRMtpXW0eHQh/OByiYe3XyMD68sYPIgPcKREYYbF09k3YGTvcO4fbHpSC3zJ6aSGDt6hSWmZycxOSOBl7y9uttK64iKMKNSaCkqMoKvXzObI9UtPLgx+IfDPvD6USKN4ZfvPweAZ9RbKiIhqmdt8PhoFTpySm9SqhoGEgaUlAZQdbOL6EhDSlxwf6DPyU0hLjpi2PNK1xdXYwycPy2wS5ismJpBR5ebt8oaBn9wAPzwuX0kxkbxuUun+/T4m5dMpNtteWpHuU+Pb+/s5s1jDaM2n7SHMYbL5mTz6qEaWl1dbCupY96ElFEptASeYksXTs/i52uLaWjtHPH+qhrbqWxs90Nkp2pq7+TRzce4ZkEuK6dmsmBiKk+/5dt7KyIy1rSpp9Rxqr4r4URJaQDVNHeQmRgb0GIx/hAdGcGivLRhzytdX3yShXlppCUEtkd4eYEnWdt4ePTnlb5+qIa1+6r4dOF00n3s+Z6Zk8yCiak8vt23Krw7jtXj6nb3HudounxODq4uN+v2n+StsgbOGcXhw8YYvn7NHBraOvnlS8Uj2tfrh2q47CfreNdvXvN7j/o/tpbR3NHFxy6cAsB1C3N5s6yBY7Wtfn0dEZFgoOG7zouO9Hx/VFIq4UBJaQDVtriCfuhuj6X56ewub+y9MuqrxvZO3ixrYNX0wA7dBU+l2Nnjk9l4ZHTnlbrdlv/33F5yU+O47YKCIT33nedMZNfxRg5UNg362E1HajEGznUgKT23IIPk2CjuLTpIW2d3wIscnW7uhBTeszSPB14/SklNy7D28dSb5dx6/yYSY6Ioq2vj4Y2lfouv223582tHWTI5rbfA1bULcwF4WkN4RSQEqfqu84wxxEZFqNCRhAUlpQFU3eIiM8gr7/ZYmp9Ol9sOec3I1w/V0O22XBjg+aQ9VkzJYGtJHZ2jOL/imZ0VvFXWwJeunDXkIa03LJ5AZITxqeDRpiO1zB6fQmpC9HBDHbaYqAgumjmOXccbAVgyOW3UY/jSlbOIiojgh8/vG9LzrLX8bt0h/uPh7SyelMbzX1jF+dMy+eVLB2nu6PJLbC/tq6KkprW3lxQ8a60unpSmIbwiEpLenlOqpNRJMUpKJUwoKQ2gmuaOoF6jtK+e4ZpbhjiEd33xSRJiIketWuyKqZm0urrZeXx05pV2dHXzvy/sY/b4ZN55zsQhPz8rKZaLZ47jX9uP0+0eeC3Ozm43W0vqRn0+aV+XzfFU4c1OjmViWvyov35OShyfvHgqz+48wZajvvWGd7st33lqN//vuX1cuzCXv9y+nLSEGL5y9WxqWlz8cf0Rv8R2/4YjTEiN4+p540/Zft3CXHaXN3Kkeni9u2OFtZaHNpbykxf3j+oFIRFxTmvvkjDBXRcj1MVGRajQkYQFJaUBVNviInOMDN/NSIxh6rjEIc8r3VBczcqpmb0V4gKtZ/3O0Voa5sE3SjlW28bXr5lDZMTw5gbfvGQiJxrbeeMsc2F3HW+grbN7VNcnPd0ls7KJMJ6lYJyaB33HRVPJSYnl+8/sxdqBk3jwDC27829beeD1Ej6xagq/vOWc3p7sxZPSeMf88fx+/WFqhlD9uD97yht5/XANHzm/gKjIU//Oe4bwPhPCvaXNHV189uHtfP2JnfzipYN8+I8bqfWuwSwioavN1Y0xEBetr4pOiomM0JxSCQv6pAmQVlcXra5uMsbI8F2ApZPT2VpaN2gy0ONYbStHa1q5cBTmk/bISoplenYSG48EvthRT+GdVTOyuGjmuGHv5/I5OSTHRfHPbQMXPNrknSfrxHzSHumJMfzwXQv5rI/VhQMhISaKL105ix3H6vn3WeZq1ra4+MAf3mD13kq+ff1cvnHtXCJOu2jwpStn0erq4t6XD40opj+9eoT46EhuOXfSGfflpsZzbkF6yM4r3X+iiRt+tYHndlbwtXfM5qfvW8S20npu+NUG9lY0Oh2eiASItZaNh2vJTYkL+mKNoS4mSkmphAclpQHSs0ZpVuLYGL4Lnnml9a2dHPZxKOL64moALpo5ekkpeOaVbjlad9bhsP7wm6JD1Ld18tWrZ49oP3HRkVy7IJfnd53onaNzuk1Hapk6LpFxyc7+vbxn2STmTwz8+qRn864leczNTeGHz+2jvfPMwlslNS286zevsae8kd98cAm3XTCln7141l99z9JJ/O2NEsrqhlcht7q5gyd3lPOupRMHrC597YJc9p1o4mDV4MWsxpLHt5Vx470baGzr4qFPrORTF0/jnefk8fdPnkdnt5t3/eY1nt8Vmsm4SLjbUlLHpqO13Fk4zelQwl5sVKRj67OLjCYlpQFS4x3eNlYKHYEnKQV8Xq90w8GTjE+JY9q4pECGdYYVUzNp7uiitClwVw7L69u4/9UjvHPxRL8kaTcvyaPV1c0Lu0+ccV+327LpaK2j80mDSWSE4ZvXzuF4fRt/fu3oKfftOFbPzb9+jbpWFw99YgVXz889676+cMUMMPDT1cNbaubBN0pxdbv56Pn9J74A1yzIxRj495uhkaC1d3bz9Sd28sXH3mRRXhrP/seFrJz69hrEiyal8e/PXsjMnGQ+9bdt/HT1AdwBvkAkIqPrtYM1GAM3LB56LQXxL/WUSrhQUhogtS2eeWxjZUkYgGnjkkiNj/ZpXmm32/LqwRounJE16kN7VnqTt721gbty+MjmY3R1u/nilTP9sr9l+elMyojvtwrv/hNNNLV3OTqfNNicPz2Ly2Znc+9LB3vnhK7ZU8kt971OQmwk/7zzfJbmD95euanxfPT8Ah7fXsb+E0Pryezo6uavb5RQOGsc07MHvvCSnRLHiikZPLOzwueh74Opa3Hx1skuTjaNbD7sUB2rbeXdv32NhzaWcmfhNB78+AqyU+LOeFx2ShyP3LGSdy3J4+dri/n0g9to8VOlYxFxhrWWF3ef4NpfrOenaw4wMzuZ1PjRrwYvp4pRoSMJE0pKA6S6Z/juGKm+CxARYVgyOc2nntKdxxtoaOtk1SgtBdNXdkocs8cn82ZV4JLStXsrWZqfTl56gl/2FxFheOfiibx6sJoTDe2n3LfJOz92+ZTM/p4atu66Zg6tnd38bE0xL5V2csdftzAzJ5nH77xgSL3zd148jaSYKH784v4hvf4zb1VQ3dzBxwYYHtzXdQsncLCqmf0+rEfriy8+toOfbO3g3LvXcOEPX+JzD2/njxuOsK20LmDDuNbsqeTaX6yntKaVP3xkGV+9evYZhZ36iouO5MfvWcg3r53Di3tO8K7fvMax2uENkxYR5+w70ciu4w3cdO+r3PHXrVQ2es5RkzL8c/6TkVGhIwkXSkoDpGdO6VgavgueIbzFVc00tHae9XEbik8CcMEoFjnq64q5ORTXu6kLQBXQioY2dpc3ctmcHL/u951L8nBbeHLHqb2lm47WMjEt3pFlWILZ9OwkPrB8Mn/bWMJf9rgonJXNI3esHPK82/TEGD5VOI3VeyrZWuJb1WZrLX/ccITp2Uk+XXi5ev54Igw87YchvK8drObl/Se5Ij+Kb1wzh4V5qWw9Wsv3nt7Dzb9+jQXffpEb732V7zy1myd3HKe0pnVEPbRd3W7ueW4fH//LFiZnJvD051Zx+Vzf/vaNMXx81VT+dNtyyuvbuPHeV89aZVpEgsP20jre+etXeW5nBVf/bD3X/XIDZXVt/O+7FvL6XZfxzWvncNc1I6unIP4RExXBlpI6XjtUrakSEtK0+FSA1LZ0EB8dOebW91rinVe67Vgdl8zKHvBx64urmZub4lhP8OVzcvjlSwcpOlDFO8/J8+u+1+6t8r7GwMc/HFOyElkyOY3Htx3njoumYozBWsumI7VcNGP41X1D2Rcun8FL+6qYldzJfR9eetaeu7O57YIC/vTqUX743H4e/eTKQYecbz5ax+7yRn7wzgU+DU/PSorl/GlZPP1WOV+6cuawh7S73Za7n93LxLR43jPTcOVFU3vvq2xsZ3tpPduP1bGjtJ5HNx/rnXObmRjDwrxU8jMTyU2NY0JaPBPSPD+zk+MGXM6oqqmdzz20nY1Hann/8sl8+/q5vcvqDMXFM8fxr89cwCf+soUP/WEj375hHh9emT+sNhCRwPvjhiNsL63nzge39W67YfEE3uutMv7xVVMHeqqMsujICKyFD/x+IwvzUnngtuWkj6GpYSK+GlsZ0xhS0+waU/NJeyzKSyMywrCtZOCktKWji22ldXzswsGHNQbKgomppMUa1uwJRFJaSX5mQkAKOL1zSR7f+tcu9lQ0Mm9CKoerW6hudmk+6QAyk2LZ8NVLWLdu3bATUvAsNfP5y6bzrSd3U3Tg5FkvuADcv+EIaQnRvPMc34t8XLcwl689vpPd5Y3DLo715JvH2V3eyE/ft4iYhoOn3JeTEsfV88dz9fzxgKeH80BlM9uP1bG9tJ5dxxvYcrSOptPmdkZGGHKSY5mQFk9uT7KaGk98TCQ/emE/Te2d/N97FvGupSP7fzR1XBJPfOYCvvDIDr71r13sq2jk29fPG7U1jEXEd0drzqyyv3hS2ugHIoMqrfW8V+dNzWRrSR13/HULv/3QUjLH0PQwEV8MmpQaY+KAV4BY7+P/Ya39tjEmA3gUKACOAu+11tZ5n3MXcDvQDfyHtfaFgEQfxKpbXGSNsaG7AImxUczJTT7rvNKNR2ro7Lasmu5c715EhGHxuEjWHThJR1c3sVFD793pT6uri1cP1fChFfkBKeB0/cJcvvvv3Ty+7TjzJqT2rk+qpHRg/nofblk+mT9sOML/Pr+fi2eMO2Nd0x7Halt5cc8JPnXxNOJjfP+7umreeL75r108/VbFsJLS9s5ufvT8fuZPTOHGRRN55ZWDZ318VGQEcyekMHdCCh9c8XavZFN7JxUN7Ryvb6Oivp3y+jbKG9oor2/jrbJ6XtjV3ls0Y2pWIn+9fTmzx6cMOd7+pMRF8/uPLONHL+znt+sOsbeikZuX5LGsIJ2Z2ckDtrmIBF5FQxtfeGQHVU0dHKlu4dOF01gwMZX/99w+SmtbWeDwcmDSvwOVzQD877sXsv1YPV98dAe/LjrEt66b63BkIv7lS09pB3CptbbZGBMNbDDGPAfcDKy11t5jjPka8DXgq8aYucAtwDxgArDGGDPTWhtWiyzVNHeQ00/VyrFg6eR0/r61jK5ud7+9U+uLq4mNimBZQboD0b1tcXYkRWUdbDxcy0Uz/ZMgbyiuxtXl9vvQ3R5pCTFcOjubJ3eUc9c7ZrPpSC1ZSbFMyUoMyOvJ26IjI/jiFTP5/CM7+Pdb5dw4wFIHD7x2lAhj+PB5Qxt+mp4YwwXTPUN4v3r1rCEn03969SjlDe38+D2LRpS8JcdFkxwXzcyc5H7vd7stNS0uKhvbmZ6dNKzhumcTGWH42jtmMyc3mbuf2cs3/7XLG1cUSyansyw/naX56SyenDbmpjeIjGXr9p9k4xFPDYMLpmfykfMKGJ8ax7lTMnh5XxVTR3l5N/HNh1fm89c3SpiUkcCkjAR+ubaY43VtTocl4neDfiOwngoazd6b0d5/FrgRKPRufwAoAr7q3f6ItbYDOGKMOQgsB173Z+DBrrbFxZxc//Q+jLYl+ek88HoJ+0409dvjs764muVTMvz+ZXao5mZGEh8dyZq9lX5LStfsrSQ5LopzA9hzefOSPF7YXcn6g9VsOuJZn3S0l9UJV9cvnMDv1h3m/148wDvm554xtLS5o4tHNx/jmgW55KYOvfDUdQtz+a9/vMWbZQ1DGgpX2+Li1y8f5JJZ4zg/wMXDIiIM45Jjh1wwaqhuXDyRGxZNoLS2lS1H69hSUse2kjp+suYA1nqS17m5KSzNT2dZQTrL8jMYnzo2L+SJjAXH6lqJijCs+6/CUy44ZyXF8p5lkxyMTM7mezfN539umNd7OzMphpqW0V0uTGQ0+HSZ2hgTCWwFpgP3Wms3GmNyrLUVANbaCmNMT9fSROCNPk8v8247fZ93AHcA5OTkUFRUNOyD6Ku5udlv+xouay0nG9tpra0clVj8fcydbZ6hfY+s2cTl+aeuUVbb7uZgVRtL012Ot7OrrYU56VE8vb2US1JOjjixc1vL82+1MScjglfXv+KnKM8U6bYkRsPdT2zleL2bS3K7fW7LYPj7doI/j/vqCV38ZGsH331w7Rl/36tLOmnq6GJxfO2wXi+h0xJl4LfPbOSW2b4nfQ/u7aC5o4vLs94+zlB6rzOBqzI8/1o6EzhU301xnZvi+iYeeqPh7YJNcYZ3THLjucYpIv5UWtvGhLT4Ec3PF2f0HT2TlRTL7vJGB6MRCQyfklLv0NvFxpg04AljzPyzPLy/zOCMGtbW2vuA+wCWLVtmCwsLfQllUEVFRfhrX8PV2N5J1wsvcs6c6RReFPgKdv4+ZmstP9q+lsaYTAoLzznlvr9vOQa8xUevXuF4T3BRURG3XDSNr/zjLbJnLWHehJHNh9leWkfjC6/xgYsXUDiEAjfDcXPjLv76RgkAH7zS97YMhr9vJ/jzuC+2lldr3+D5Yy3cdcuFJMZ6Pgbdbsu3/6+IJZMT+NhNFwx7/0+Ub+at8kZ+fdHFPg3DPVrdwssvruOW5ZP44PULe7eHy3vd2e1mT3kjW0vq2FpSR1Z0bVgct8hoO1bbymStPTrmZSXFUt2snlIJPUO6XGatrcdzCftqoNIYkwvg/VnlfVgZ0HccSB5QPtJAx5LaMbpGaQ9jDEvz0/stdrS+uJqspFhmj+9/vtpou3R2NsbAmj1Vgz94EGv3VhEZYSicFfgCTjcv8SS9KXFRzBpg7p8EhjGGr75jNtXNHfzp1SO921/aV0VJTeuIq0pft3AC5Q3tbD82cLGwvv73hX3EREXwn5fPHNHrjlXRkREsmpTGxy6cwr0fXMLibM0z9QdjTKQxZrsx5mnv7QxjzGpjTLH3p7NFAWTUVDa289mHtrHjWD2TMrQe9liXmRhDU3sXHV1hVapFwsCgSakxZpy3hxRjTDxwObAPeAq41fuwW4Envb8/BdxijIk1xkwBZgCb/Bx3UOsZ6z8Wl4TpsTQ/g+P1bZxoaO/d5nZbXj1YzYXTM4NmDmRWUixLJqezZm/liPe1Zm8ly/LTSUsI/Pu2eFIas8cns2rmwFVgJXCWTE7nyrk5/G7dYepaPBeR7n/1CBNS47h63vgR7fuyOdnEREXw7zcrBn3s1pI6nt15gk+smkr2GC2MJkHr88DePre/hqc44Qxgrfe2hLiqxnZu/NWrPP2W5/NoOHPlJbhkeesB1Hg7QERChS89pbnAy8aYt4DNwGpr7dPAPcAVxphi4Arvbay1u4HHgD3A88Bnwq3ybrX3gyJrDK8htTTfcxF9W+nbvT17TzRS0+Ji1QznloLpz+Vzcth5vIGKhuFXoyura2XfiSYun5Pjx8gGZozh0U+ex4/evXDwB0tAfPmqWbS4uvh10UH2VjTy2qEaPnxewYjnWyXHRXPJrHE8u7MCt/uMmQu9rLXc/cwexiXHcscoDPOX8GGMyQOuBf7QZ/ONeIoS4v150yiHJQ54+q0KTjS286/PXMAfb13GrecVOB2SjFCmt8NDSamEmkG/fVlr37LWnmOtXWitnW+t/a53e4219jJr7Qzvz9o+z7nbWjvNWjvLWvtcIA8gGNWM8eG7AHNzU4iNijhlCO/64moALpwR2OqgQ3XFXE+NrbV7hz+E96V9nudeFqClYPqTGh+tJTEcNDMnmZuX5PHA6yX88Pl9xEVH8P7l/qlAed3CCVQ1dbD5aO2Aj3l+1wm2ldbzn5fP7J3XKuInPwO+Arj7bDulOCEweh924pj1xSeZkpXI4klpXDYnh9SE6MGfJEGtp6d0/cGTDkci4l/6JhQAtSEwfDcmKoJFeWmnJKUbiquZmZMUdOuvThuXREFmAmv2VvKhlUNbW7LHmr1VTM1K1DptYeY/r5jJUzvKKdp/kg+umOy3oduXzckmLjqCp9+qYMXUzDPud3W5+eHz+5iencR7l+X55TVFAIwx1wFV1tqtxpjCYTw/ZCvjBzu/V9J3W1492MqqiVEh1fbh/rfU5bbMy4zgf5/fj6kpYU5m/8vzhXs7+UJt5JvRaiclpQFQ3ewiOTaK2Chn1/EcqSX56fxxw2HaOz2jrzcdreXDw0z6AskYw+VzcvjL6yW0dHQNudepuaOLNw7VcOv5wXdsElgT0+L5yHn53P/qEW67oMBv+02IieKy2Tk8t6uCb18/94whwQ9tLOFoTSv3f3SZlmcQf7sAuMEYcw0QB6QYY/6Gtzihdwm3vsUJTxHKlfGDnb/b6LWD1bi6N/L+wsUUzh2dqSmjQX9LcOGqbq762Ss8eNDy76vPJ72fThC10+DURr4ZrXbSt6EAqGlxjemhuz2W5qfT2W3ZebyBTUdqcXW5g27obo/L5+bg6nazvnjow1k2FJ/E1e3mslGaTyrB5StXz+a5z1/E9Gz/VkG+bmEu1c0uNh05dQhvY3snP19bzHlTM7lklkZQin9Za++y1uZZawuAW4CXrLUfYuDihBKi1hWfJCrCsHLamaM1ZGyLi47kF7ecw4mGdn6//rDT4Yj4hZLSAKht6SBzDBc56rFkchrgqRC64WA1MZERrJiS4WxQA1iWn05qfDSrh7E0zOo9VaTGR7MsXyskhKOYqAhmBWCJo0tmZ5MYE8m/3zq1Cu9vig5R19rJ16+ZEzRVrCUs9FucUELXjtJ6FuSlkqQ56yFp0aQ0Zucms/N4g9OhiPiFktIAqGl2jen5pD0yk2KZkpXI1pI61hdXszQ/PWgL80RFRnDp7Gxe3l9F91kqnp6u2215eX8VhbPGaRil+FVcdCSXz83h+V0VdHZ76s2U17dx/4Yj3LR4AgvyUh2OUEKdtbbIWnud9/cBixNKaKptcZGdPPYvkMvA5oxPYW9Fo9NhiPiFvoUHQHWzi6wQGL4LnvUcXz9Uw96KxqAdutvj8jk51La42N5nGZvB7DhWR22LS0N3JSCuXZBLXWsnrx2qAeDHL+7H4lmORkQkkOpaO0PiArkMbE5uCtXNLsrqWp0ORWTElJT6mdttqWt1kZkYGlcnl+an09zRBcCqIE9KL5qZRXSkYfXeSp+fs2ZvFVERhotnBtfaqxIaLp41juTYKJ55q5xdxxt4Yvtxbju/gLz0BKdDE5EQZq2lvtXlt4riEpyWFXimHd3869eoamx3OBqRkVFS6mcNbZ10u23IXJ1c6p1nmZ4QzbwJwT3cMDkumpVTM1mzx/ekdO3eSs4tyCA1Xmu3if/FRkVyxbwcnt91gu8/s4fU+Gg+fcl0p8MSkRDX3NFFl9uSrnVJQ9rCvDT+fNu5NHd0ceO9r/KT1Qeob3U5HZbIsCgp9bMa7xqloVB9F2BGdhLpCdGsmjGOyIjgL8pyxdwcDp1s4fDJ5kEfe6y2lQOVzVw2RxVQJXCuXziBxvYu3jhcy+cunaELICIScPWtnQDqKQ0DhbOy+evtK5g6LpFfvVTMLfe94XRIIsOipNTPqps9V6iyQqD6LkBEhOHRT57Hf18/1+lQfNIzN3Tt3sGr8K7xDvO9IoTWb5Pgc8H0LFLjo8nPTAjKdX5FJPTUeXvL0pWUhoWl+ek8+PGV3HHRNA5UNmGt7wUfRYJFcJZSHcNqWzwnglDpKQWYmeP/5TICZWJaPHNzU1i9t5JPXDT1rI9du7eK6dlJ5GcmjlJ0Eo5ioiL4463LSImPJiZK1wFFJPDqvD2lGr4bXtITonFbaHF1Ox2KyJDpG5Kf1TR7hu+GypzSsejyuTlsOVpLXcvA8yoa2zvZeKRGQ3dlVCwryBhTF3dEZGzrmVeo4bvhJTnOcxGiqb3T4UhEhk5JqZ/1DN/N0InAMVfMycFt4eX9Aw/hfeXASTq7LZdrKRgREQkxPRdldYE8vCTHeQZANrV3ORyJyNApKfWzmpYO0hOiiYpU0zpl/sQUclJie+eM9mft3irSE6JZMjl9FCMTEREJvPo2T09ZSpxmaYWTt5NS9ZTK2KPMyc9qW1y6MukwYwyXz8lh3f6TdHSdOa+iq9vNy/uruGRW9pioKCwiIjIUjW1dJMVG6QJ5mOkZvtuonlIZg/Rp5WfVzS4yQ6Ty7lh2+dwcWlzdvHG49oz7tpXWU9/a2VupV0REJJQ0tneqlzQMpWj4roxhSkr9rKa5g6wQqrw7Vp03NZOEmEjW7DlzCO/avZVERxoumpnlQGQiIiKB1djWSYrWRA47KnQkY5mSUj+rbXGRmaieUqfFRUdy0YxxrNlbecZ6XWv2VrJiSmbvh7eIiEgoaWrvIkXnuLCjQkcylikp9aOubjd1rZ2aUxokLp+bQ0VDO7vLG3u3Ha1u4dDJFi0FIyIiIauxvZOUeA3fDTcJMZFERhj1lMqYpKTUj2q964Jp+G5wuGTWOIzhlCq8Pb9rKRgREQlVje2dGg0UhowxJMVGqadUxiQlpX5U412jVIWOgkNmUixLJ6efkpSu3VvFzJwkJmUkOBiZiIhI4DS2danQUZhKjouioU09pTL2KCn1o1otVh10Lp+bw67jjVQ0tNHQ2smmo7WquisiIiHL7bY0tavQUbiamZPM029VsK/2zCXxRIKZklI/qm7uADR8N5j0DNNds7eKogNVdLuthu6KiEjIanF14bao0FGY+un7FuO2lr01SkplbFFS6ke9w3dVfTdoTBuXyJSsRNbsqWTt3ioyE2NYPCnN6bBERET84rHNx1j5g7X8pugQnd1u7nvlMIAKHYWp1PhoxqfEUd1mB3+wSBDRJ5Yf1ba4iIwwpGrITNAwxnD5nGweeK2E2OgIrpo3nsgI43RYIiIiI7bvRCPf+NdOOrstf9xwmJf2VbL5aB0ACTH6iheu8tLjqW5ocDoMkSFRT6kf1bR0kJ4QQ4SSnqBy+ZwcXN1umtq7uFxLwYiISIj4bdEhYqMi+dyl06ludrH5aB13XDSVRXmpLMxLdTo8cUheeoJ6SmXM0WU0P6pudmk+aRBamp9OWkI0rR3drJoxzulwRERERqyqqZ1ndlbwwRX5vHtpHr986SB3vWM2n7x4mtOhicPy0uOp67B0dbuJilT/k4wNSkr9qLbFRaaS0qATFRnB7RdMob6tk8RY/cmLiEjwa3N1860nd1Fe38ZvP7z0lMJFRfur+OifNgPwkfPyyc9MZPf/XKVznAAwKSMBt4X/fmo3t51fQGpCNOOSYjFGI/kkeOnTy49qmjtYkJfmdBjSj89dNsPpEERERHz2j63H+MfWMgD++1+7+NF7FuHqcpMYG8Uv1hYDcNnsbKaOSwJQQiq9rl84gade38PftxzjoY2lAKTERXFn4XTuLFRPugQnfYL5UU2zi0ytUSoiIiIj8OjmUr715G7mTUjhirk5/GxNMc/uOgEWvnjlTHYdb+TmJRP53o3znQ5VglB8TCQfXxDLTz66kmffqsBt4ZXik/zw+X0U7a/itgumcPX88U6HKXIKJaV+0tHVTVNHl+aUioiIY4wxccArQCyec/w/rLXfNsZkAI8CBcBR4L3W2jqn4pSz++e24wB89erZnD8tk/rWTiIjDLuON3DPc/sAuGHRBPWOylllJ8fx0QumAHDr+QX86dUj/Pm1o3zqb1v5+S2LuXHxRIcjFHmbZj/7SW2Ld43SJK1RKiIijukALrXWLgIWA1cbY1YCXwPWWmtnAGu9tyVIHa9r453nTOSimeOIiozgOzfM41vXzeXr18wBYFxyLBdMz3I4ShlLIiMMH181lbVfupglk9P47r/3cKCyyemwRHopKfWTmmZPUpqh4bsiIuIQ69HsvRnt/WeBG4EHvNsfAG4a/ejEF13dbk40tjMxLf6M+xZNSuNPHz2X5z+/imhVVZVhiI2K5Ps3LcDV5eaan6/n/z27l0c2leJ2awkZcZbGffhJdXMHgIbvioiIo4wxkcBWYDpwr7V2ozEmx1pbAWCtrTDGaNHmIHWisZ1utyUv/cykFOCS2XrrZGTmTkhh3Vcu4RtP7OR3rxwGPBV71fsuTlJS6ie9w3cTNXxXREScY63tBhYbY9KAJ4wxPlfDMcbcAdwBkJOTQ1FRkV9iam5u9tu+QlVPG+2v7QagurSYotbDDkcVfPS35Btf2ul9eXBlVjz/WdTGP4q20VkWXh0r+lvyzWi1k5JSP+kdvqueUhERCQLW2npjTBFwNVBpjMn19pLmAlUDPOc+4D6AZcuW2cLCQr/EUlRUhL/2FaqKiorImbWEv7ywH2jn2sKVTMlKdDqsoKO/Jd8MpZ1+u/cVaiPiKCxcHtiggoz+lnwzWu2kCQl+Ut3SQUxkBMmqhCciIg4xxozz9pBijIkHLgf2AU8Bt3ofdivwpCMBylnd/ufNvLSvipsWTyA/I8HpcCRMLCtIZ+ORGl7aV6m5peIYJaV+UtPsIjMpBmOM06GIiEj4ygVeNsa8BWwGVltrnwbuAa4wxhQDV3hvSxDpclsqGtu57YICfnbLOURE6PuEjI7PXDKdxJgoPvbnLbzvvtdZvaeSzm6302FJmBk0KTXGTDLGvGyM2WuM2W2M+bx3e4YxZrUxptj7M73Pc+4yxhw0xuw3xlwVyAMIFrUtnqRURETEKdbat6y151hrF1pr51trv+vdXmOtvcxaO8P7s9bpWOVUjS6LtTAjO9npUCTMTEiL57kvrOLb18/lSHULn/jLFm6699XeIp4io8GXntIu4EvW2jnASuAzxpi5DLDmmfe+W4B5eOax/NpbCTCk1TR3kKEiRyIiIjIMde2eYZM5KfouIaMvOzmO2y6Ywut3XcbPb1nM7vJG/rm1zOmwJIwMmpRaayustdu8vzcBe4GJDLzm2Y3AI9baDmvtEeAgEPIzp6ubXWRpjVIREREZhreT0jiHI5FwFh0ZwY2LJzJtXCJvHK5xOhwJI0OqymOMKQDOATYCA615NhF4o8/TyrzbTt9XSJWdP9nURmtdpSOvHa4lrcPxuMPxmCE8jzscjxnC97hF6js8Sen4VCWl4ryVUzN5ckc5ba5u4mNCfsCjBAGfk1JjTBLwT+AL1trGsxT06e+OM0p5hVLZ+VZXF67nX2DR7OkUFk4b1deG8C1pHY7HHY7HDOF53OF4zBC+xy3hraGtk5JGN9GRhowEjboS5127MJeHNpVy6/2b+O2Hl5Kh0YASYD5V3zXGRONJSB+01j7u3VzpXeuM09Y8KwMm9Xl6HlDun3CDU88apSp0JCIiIr5wuy1vHqvnkU2lLPv+atYf72JSeoKq7kpQOH9aFr+45Rx2lNVz470bVPRIAm7QnlLj6RL9I7DXWvuTPnf1rHl2D6euefYU8JAx5ifABGAGsMmfQQebnv+oWUpKRUREZBDdbst//f1NHt9+HIC89HhW5XTz2ZtWOByZyNuuXzSB1PhoPnL/JjYUV3PTOWfMxhPxG1+G714AfBjYaYzZ4d32dTzJ6GPGmNuBUuA9ANba3caYx4A9eCr3fsZa2+3vwINJbYu3p1TVd0VERGQQ33t6D49vP84HV0zmqnnjObcgg42vrWdiWrzToYmc4tyCDADK6lodjkRC3aBJqbV2A/3PEwW4bIDn3A3cPYK4xpSe4bsaby8iIiL9OVjVxAu7K/nZmgN0dls+tHIy379pgdNhiZxVfEwkWUkxHK9vczoUCXFDqr4r/atu8Qzf1ZxSEREROZ21lo/9eQultZ7epuTYKL5w+UyHoxLxzcS0eMrqlJRKYCkp9YPaZhcJMZEkxKg5RURE5G3WWv7yegmlta2smJLBj9+ziJS4aFITop0OTcQneekJ7K1odDoMCXE+Vd+Vs6tpcWnoroiIiJyiq9vN1pI6vv3UbhJjIrnvw8uYlJGghFTGlInp8ZTVt9HtPmOFRxG/UVLqB9XNHWQmqciRiIiIeDy7s4Lp33iO368/DMCaL12sZFTGpMWT0nB1uXml+KTToUgIU1LqBzXNLrLUUyoiIiJej24+BsALuytZMSWD3FRV1pWx6fI5OWQlxfLjF/ZrvVIJGCWlflDb4lKRIxEREel1sKqZmMgIVs3I4uOrpjodjsiwxURF8P2b5rP/RBO/f+Ww0+FIiFJlnhGy1lLT0kGG1igVERERPGs6Hq9v4zvXz+WjF0xxOhyREbt6/njmTUhh5/EGp0OREKWe0hFqbO+is9uSpZ5SERERATYfrQVg+ZRMhyMR8Z+5E1LZXd6ItSp4JP6npHSEaltcgNYoFREREY9NR2pJiYti1vhkp0MR8Zu5E1JoaOtkj5aHkQBQUjpCNd4J35kavisiIiLAxiO1nFuQQWSEcToUEb9ZNT2L+OhI3nnva3z333t6O2ZE/EFJ6QhVN3v+Q2qdUhEREalu7uDwyRaWT8lwOhQRvyrISuTlLxfyznMm8ufXjnDx/77MI5tKnQ5LQoSS0hGqafH0lGZpnVIREZGwt+VoHQDLCpSUSugZnxrHD9+9kBe+cBFTxyVy9zN7nQ5JQoSS0hGqVU+piIiIeG05WktsVATzJ6Y4HYpIwMzISeaS2dk0dXTR1e12OhwJAUpKR6imxUVyXBQxUWpKERGRcLe5pI5Fk9KIjYp0OhSRgEqNjwY8K1GIjJQyqRGqbu7Q0F0RERGh1dXF7uMNnFuQ7nQoIgHXm5S2dTociYSCKKcDGOtqW1xkauiuiIhIWDpY1Ux5fRs7jtXz5rF6utxW80klLKTEeZLSBiWl4gdKSkeoptlFQVaC02GIiIjIKPvBs3u575XDABgDeenxXD4nmxWqvCthIDVBSan4j5LSEapp6WBJvobpiIiI84wxk4C/AOMBN3CftfbnxpgM4FGgADgKvNdaW+dUnKHA7bY8uvkYy/LT+eKVM5k3IbV3OKNIOHh7TqmSUhk5zSkdAbfbUtviIitJw3dFRCQodAFfstbOAVYCnzHGzAW+Bqy11s4A1npvyzBZa3lpXxUNbZ2899xJnD8tSwmphB0N3xV/Uk/pCNS3deK2aE6piIgEBWttBVDh/b3JGLMXmAjcCBR6H/YAUAR81YEQx7zq5g4+/sAWdhyrB2CpRktJmOq5EKOkVPxBSekI1DR3AJCh6rsiIhJkjDEFwDnARiDHm7Bira0wxmQP8Jw7gDsAcnJyKCoq8ksszc3NftuXU1zdlgf3unijogtr4ZzsSKIioHTXZo4ZM+L9h0IbjQa1k29Go52stUQZ2LX/MEWUBfS1AkF/S74ZrXZSUjoC1c0uALLUUyoiIkHEGJME/BP4grW20fiYNFlr7wPuA1i2bJktLCz0SzxFRUX4a19O+cfWMtaVvcnNSyZy+4VTmDch1a/7D4U2Gg1qJ9+MVjulvbqaxIxsCgsXBfy1/E1/S74ZrXbSnNIRqG3xJKWZ6ikVEZEgYYyJxpOQPmitfdy7udIYk+u9Pxeociq+seihjaV8+e9vkp+ZwP+9Z5HfE1KRsWpiegJ/31rGruMNTociY5yS0hGoafEM381UoSMREQkCxtMl+kdgr7X2J33uegq41fv7rcCTox3bWNXU3sn/e24vAHdePA1fe51FwsHdN80H4I3DNQ5HImOdhu+OQHWzC2MgPUFJqYiIBIULgA8DO40xO7zbvg7cAzxmjLkdKAXe40x4wctay6GTLVQ2ttPU3snkjER++Pw+Nhyspttt+eed56uokchp5uamYAw0qtiRjJCS0hGoae4gPSGGyAhdNRUREedZazcAA52ULhvNWMaaF3ZX8qm/bT1lW0xkBB9fNYWLZoxTQirSj4gIQ0pctCrwyogpKR2B2haXloMREREZ46y1/PWNowD85L2LmJyRwIHKZpZPyWB6dpKzwYkEuZT4KCWlMmJKSkegptlFhpJSERGRMWlDcTXP7arg5X1VlDe0819XzeLmJXkALCvIcDg6kbEhNV49pTJySkpHoLqlgznjU5wOQ0RERHz023WHeH7XCfZWNNLR5SYmMoJLZo/ji1fO4p3nTHQ6PJExR0mp+IOS0hGobXGp8q6IiMgYseNYPfc8t48FE1OZlJFAYmwUD358BUmx+jokMlyp8dFUNnY4HYaMcfoUHqbObjf1rZ1kJmqNUhERkbHgl2uLSUuI5uE7VpIYE4m1nkItIjJ86ikVf1BSOkx1LS4AMtRTKiIiEpRaOrrYeKSGrKRYHtpYytp9VXz5ypm9PaNaclRk5FR9V/xBSekwVTd7ktIsFToSEREJOu2d3Vzzi/WU1LQCEBlhWDUji4+cX+BsYCIhJiU+GleXm/bObuKiI50OR8YoJaXDVOvtKc1M0vBdERGRYFNc2UxJTStfvXo2E9LimDchhenZyU6HJRJyUuOjAXjlwEmunDfe4WhkrFJSOkw1LZ4J3VoSRkREJPjsO9EIwFXzcpg6TmuNigTKuQUZJMVG8dV/vsWls7OJioxwOiQZg/RXM0y9w3c1p1RERCToHKhsIiYqgvzMRKdDEQlps8Yn8/9uXkBdaydvltU7HY6MUUpKh6m2pYOoCENKXLTToYiIiEgf+0808cDrJczITiJS1XVFAu6iGeOIMPDMWyecDkXGKCWlw1TT7CIjMUal5EVERIJIRUMb7//9G0QYeNeSPKfDEQkLqQnR3LR4In9+7Qg/emEf1lqnQ5IxZtCk1BhzvzGmyhizq8+2DGPMamNMsfdnep/77jLGHDTG7DfGXBWowJ1W7U1KRUREJHg8+EYp9a0unv7cKj524RSnwxEJG99/53zOmZzOvS8f4nB1i9PhyBjjS0/pn4GrT9v2NWCttXYGsNZ7G2PMXOAWYJ73Ob82xoRkbeialg6yVHlXREQkKDS0dfKT1Qf41csHWTVjHNOzVdxIZDQlxETxnevnAZ4h9CJDMWhSaq19Bag9bfONwAPe3x8Abuqz/RFrbYe19ghwEFjun1CDS22Li0wVORIREXGUq8vNjmP13Hr/Jn75UjHL8tP5ytWznA5LJCzNyEnCGCWlMnTDXRImx1pbAWCtrTDGZHu3TwTe6PO4Mu+2kFOj4bsiIiKOOl7fxp1/28pbZQ1ERhh++f5zuG7hBKfDEglbcdGRFGQm8lZZPW63Ve0V8Zm/1ynt7y+v35nOxpg7gDsAcnJyKCoq8ksAzc3NftvXQFzdluaOLhqrjlNUdDKgr+WL0TjmYBSOxx2OxwzhedzheMwQvsctQ1Pb4uJzD2/j1YM1AHzh8hl8YPlkslPiHI5MRFZOzeThTaVc+n9FPPbJ8/T/Unwy3KS00hiT6+0lzQWqvNvLgEl9HpcHlPe3A2vtfcB9AMuWLbOFhYXDDOVURUVF+GtfAymvb4PVL3HugtkULp8c0NfyxWgcczAKx+MOx2OG8DzucDxmCN/jFt/tOFbPfz66g/L6Nv7rqlmcMzmN86dlOR2WiHh954a5zJ+Ywjee2MWGg9XcrCrY4oPhLgnzFHCr9/dbgSf7bL/FGBNrjJkCzAA2jSzE4FPT7AIgU4WORERERs2Wo7Xc/OtXaWrv5MGPr+Azl0xXQioSZGKjInuXYyqra3M4GhkrBu0pNcY8DBQCWcaYMuDbwD3AY8aY24FS4D0A1trdxpjHgD1AF/AZa213gGJ3THVLB4DmlIqIiIwSt9vyzX/tIjc1nmc/v4rU+GinQxKRAcRFR5KdHEtZXavTocgYMWhSaq19/wB3XTbA4+8G7h5JUMGu1ttTmqXquyIiIgHX0NrJfesPse9EEz9732IlpCJjQF56vHpKxWf+LnQUFmq8PaUavisiIhJYv1hbzC9fKqaz2zJvQgrXLcx1OiQR8UFeegI7jtU7HYaMEUpKh6Gm2UVMVASJMZFOhyIiIhKyOrvd/G7dIc4tyOC/rprFgompREUOtxyGiIymvPR4nnqznPf97nU6u91cv2gCt55XoGVipF9KSoehutlFVmIMxug/lYiISKC8VdZAi6ubD6/M55zJ6U6HIyJD8K6leew/0cTafZ5FOraV1rPxcC3/995FJMYqBZFT6S9iGGpbOjR0V0REgpIx5n7gOqDKWjvfuy0DeBQoAI4C77XW1jkVoy8qG9v5xF+2AJ51D0VkbJk2Lok/fvRcdh1vID8zgUc3H+MHz+7l5l+3cNsFBVyzMJeUOM0PFw+NgRmGmhYXmSpyJCIiwenPwNWnbfsasNZaOwNY670d1B7dfIzaFhffuGYO6ap2LzJmzZ+YSnJcNB9fNZU/3bacts5uvvb4Tt7xs/XsOt7gdHgSJJSUDkNNs0vLwYiISFCy1r4C1J62+UbgAe/vDwA3jWZMQ1Xf6uLJHcc5tyCdT1w01elwRMRPLp45jnX/VchjnzwPt7Vc98sNXPPz9fz1jRK63dbp8MRBSkqHyFpLTUsHWRq+KyIiY0eOtbYCwPsz2+F4BvTyvipW/fBlDle38KGV+U6HIyJ+Zoxh+ZQMnvrshXzxipkYA9/61y5+v/6w06GJgzSndIhaXd20d7rJVE+piIiEGGPMHcAdADk5ORQVFfllv83NzYPuq7HDUlTWydOHO8mON3x1WTyp9cUUFRX7JYZg50sbidrJV2OlnRZGwoIFlv9zRfLz1fsoO3qYi/KiiIkMfDHRsdJGThutdlJSOkQ1zS4ADd8VEZGxpNIYk2utrTDG5AJV/T3IWnsfcB/AsmXLbGFhoV9evKioiMH29aE/bGTDwWqmjUvkl+9fwtwJKX557bHClzYStZOvxlo75c9v5ouPvcnf9tZzsCOJ/3vvYiamxQf0NcdaGzlltNpJw3eHqLqlA0DDd0VEZCx5CrjV+/utwJMOxnKGqqZ2XjtUzZ2F01j7pcKwS0hFwt3UcUn86zMX8IN3LuCNw7Vc8ZN1tHd2Ox2WjCIlpUNU6+0pVfVdEREJRsaYh4HXgVnGmDJjzO3APcAVxphi4Arv7aBQVtfKj57fj9vCTYsnOh2OiDjoAysm89WrZ9Pq6mbfiSanw5FRpOG7Q1Tj7SnVOqUiIhKMrLXvH+Cuy0Y1EB/84Nm93PeKp7jJJy+eyqzxyQ5HJCJOu25hLj98fh+7yxtYPCnN6XBklCgpHaLqnp5SzSkVEREZtgOVTfxh/WGuXzSB/7h0OjNylJCKCOSlx5MSF8WmI7W8d9kkoiM1sDMc6F0eotoWF4kxkcRFRzodioiIyJhjreV4fRvfe3oPibFRfPeGeUpIRaSXMYal+ek8uaOcJd9bzc/WHMBarWEa6tRTOkQ1zR0auisiIjIMm4/W8quXDrLuwEkAvnntHNI18khETnPvB5fwyoFqnthexs/WFPPG4Ro+efE0CmeOw5jALxcjo09J6RDVtLi0HIyIiMgQHKjr5g/eJV9ioiL40hUzWTVzHIvyUp0OTUSCUEJMFFfPH89V83L45UsHeWhjKbf9aTOTMxK46x2zeceCXKdDFD9TUjpE1c0uJqbFOR2GiIhI0Gvp6OI/Ht5O0f520hPdfP6yGXx81RSS46KdDk1ExgBjDP9x2Qw+efFUnn6zgj9sOMIXHt3BjJwkpmdr2H8o0ZzSIapt6SAzUcN3RUREBpMQE0ljeycXTIzi+S9cxH9eMVMJqYgMWWxUJO9amscDt51LYmwUn31oOzuO1WuuaQhRT+kQWGupaXZpjVIREREfGGP4+6fOp6ioiCzVYxCREcpOieMn713Epx/cxk33vkpeejwrp2aycmom75g/nsRYpTZjld65IWhs66LLbTWnVERERETEAYWzstn49cv495sVvHLgJGv3VvKPrWUcqGzi69fMcTo8GSYlpUNQ09IBoKu9IiIiIiIOSY6L5gMrJvOBFZNxuy3v+u1rbCupczosGQHNKR2CmhYXgIbvioiIiIgEgYgIwzmT0tlV3kBXt9vpcGSYlJQOQU2zp6dUw3dFRERERILDokmptHe6+daTuyipaen3MdtL67jul+v5zIPb+Peb5bR2qkhSMNHwXR+1ubq575XDxEZFkJeW4HQ4IiIiIiICXDg9i2X56Tyy+RgPbzrG/IkpXDo7h/OmZjJvYgopcdH8fWsZByqbqW5y8czOCgwwb996ZmYns2hSGu9emqdCSQ5Sy/ugq9vN5x7ezvZj9fzmg0tJTVA5exERERGRYJCZFMs/7jyf8vo2ntxRztq9lfzqpWJ+sbYYgCWT09hWWs+Vc3P4zYeWsr74JP9ct4P6yBheP1zD49uP8/O1xdx+4RTOLchg/sQUEmKUJo0mtfYgrLX891O7WbO3ku/eOI+r5493OiQRERERETnNhLR47iycxp2F06hrcfFmWT27jjfwu3WHAbh8bg6REYbCWdlQEUNh4QoAtpXW8bM1xfzohf0AxEZFUJCZyOTMBBblpbKsIIMVUzIwxjh2bKFOSekg7n35IA9tLOXOwml85LwCp8MREREREZFBpCfGUDgrm8JZ2dx6fgGlta3MHp/S72OXTE7nLx9bTlldKwcqm3j1YA0lNa0cOtnM6j2VAMzITuKimeO4cHoWy6dkaKivn6k1z+LvW47x4xcPcPM5E/nKVbOcDkdERERERIYoOS6aeRNSB31cXnoCeekJXDo7p3dbQ1snz++q4Kk3y/nrGyX8ccMRoiIMiyalMTMnickZieRnJpCbGkduajzpidFYC3HRkYE8pJCjpHQARfur+NrjO1k1I4t73rVQ3fUiIiIiImEmNT6a9507mfedO5n2zm62ltSx4WA1m47U8uLuyt4lI0+XHBdFdnIs2clxZKfE9v6+IC+VJZPTiYnSIih9KSntx86yBj794DZm5STzmw8t1R+NiIiIiEiYi4uO5ILpWVwwPat3W1N7J6W1rZxoaKeioZ36VhfGGE42dVDV1E5lYwfbSuuoauygo8uzjmpUhCEvPZ7JmYnMzE5iZk4ykzISWDk1fOetKik9TWlNK7f9eRPpCTH8+bZzSdJ4cRERERER6UfP0ODBhgdba6lv7WTT0Vp2HKuntKaVktoW/vJGDS5vsvqfl89kxdQMclLiyE2NC6shwMq4+qhp7uDWP22iy2155GPLyU6JczokEREREREZ44wxpCfGcNW88Vw17+3VPNo7uznZ1MHXn9jJT9ccOOU5GYkxTM5IYGpWIgXef5MzEhifEse45FgiI0KnV1VJqVebq5vbH9hCeX0bD31iBdOzk5wOSUREREREQlhcdCSTMhL400fP5UBlM7UtLiob26loaON4fTslNS29a6n2FRlhyEyMISsplsykGNISYkhPiO79mZ4QQ6r3Z8/2lLiooB0erKQU6Op287mHt/FWWT2/+dBSluZnOB2SiIiIiIiEiajICOZO6H/JGvB0oJXUtnC8ro2KhnZONLRzsqmD6uYOalpcHKttpa61k8b2Tqztfx+REYa0+GjS+iSvp/6MYdb4JEdyobBPSq21fOvJXazZW8X3bpp/Sne6iIiIiIiI0+JjIpk9PmXAtVZ7dLstDW2d1LW6qG91Ud/aSV1rJ/WtLupaXb2/17d2cry+nd3ljdS1umjv9MxrjYwwbP3m5aQlxIzGYfUK+6T0ly8d5OFNx/jMJdP48Mp8p8MREREREREZlsgIQ0ZiDBmJQ0sq2zu7efVgNbc/sIU3Dtdy9fzR7agLqaR0zZ5Ktp/oomHHcTq63HR2u3H1+enqtqfcbmjr5Kk3y7l5yUS+fOUsp8MXEREREREZdXHRkayaMY746EgeeO0oJxraSIqLpqSyi2m1rUzKSAjo64dUUvqpv22ly21hx44BHxMTGUF0pCEmKoLoyAhuXDyBe25eGLSTfkVERPzFGHM18HMgEviDtfYeh0MSEZEgERMVwTULcvnntjJeP1zTuz0zr5KPXjAloK8dsKTUiRPfvz5zAdu3beX8lcuJiYwgJirCk4T2/Iw0Sj5FRCQsGWMigXuBK4AyYLMx5ilr7R5nIxMRkWDxf+9dxA9unk9LRzfN7V0Uvfo671g4IeCvG5Ck1KkT3/yJqVQXRzBtnJZzEREROc1y4KC19jCAMeYR4EZASamIiPSKjYokNirSs05qSiTjkmMD/poRAdpv74nPWusCek58IiIi4oyJwLE+t8u820RERBwVqOG7/Z34VgTotURERGRw/c1fOWU1O2PMHcAdADk5ORQVFfnlhZubm/22r1ClNvKN2sk3aqfBqY18M1rtFKikVCe+URSOxwzhedzheMwQnscdjscM4Xvco6QMmNTndh5Q3vcB1tr7gPsAli1bZgsLC/3ywkVFRfhrX6FKbeQbtZNv1E6DUxv5ZrTaKVBJqU58oygcjxnC87jD8ZghPI87HI8Zwve4R8lmYIYxZgpwHLgF+ICzIYmIiARuTmnvic8YE4PnxPdUgF5LREREBmGt7QI+C7wA7AUes9budjYqERGRAPWUWmu7jDE9J75I4H6d+ERERJxlrX0WeNbpOERERPoK2DqlOvGJiIiIiIjIYAI1fFdERERERERkUEpKRURERERExDFKSkVERERERMQxxlo7+KMCHYQxJ4ESP+0uC6j2077GinA8ZgjP4w7HY4bwPO5wPGbw33HnW2vH+WE/YUvn5lGnNvKN2sk3aqfBqY184892GvDcHBRJqT8ZY7ZYa5c5HcdoCsdjhvA87nA8ZgjP4w7HY4bwPe5Qp/d1cGoj36idfKN2GpzayDej1U4avisiIiIiIiKOUVIqIiIiIiIijgnFpPQ+pwNwQDgeM4TncYfjMUN4Hnc4HjOE73GHOr2vg1Mb+Ubt5Bu10+DURr4ZlXYKuTmlIiIiIiIiMnaEYk+piIiIiIiIjBEhk5QaY642xuw3xhw0xnzN6XhGizHmqDFmpzFmhzFmi9PxBIIx5n5jTJUxZlefbRnGmNXGmGLvz3QnYwyEAY77O8aY4973e4cx5honY/Q3Y8wkY8zLxpi9xpjdxpjPe7eH9Pt9luMO2ffbGBNnjNlkjHnTe8z/490e0u91uAnXc3N/hnouM8bc5W23/caYq5yJenQN5xwQpu005M/PcGwnAGNMpDFmuzHmae9ttdFp+sslnGinkEhKjTGRwL3AO4C5wPuNMXOdjWpUXWKtXRzCZa3/DFx92ravAWuttTOAtd7boebPnHncAD/1vt+LrbXPjnJMgdYFfMlaOwdYCXzG+3851N/vgY4bQvf97gAutdYuAhYDVxtjVhL673XY0Ln5DH/Gx3OZt51uAeZ5n/Nrb3uGuiGdA8K4nYb0+RnG7QTweWBvn9tqo/6dnkuMejuFRFIKLAcOWmsPW2tdwCPAjQ7HJH5irX0FqD1t843AA97fHwBuGs2YRsMAxx3SrLUV1tpt3t+b8JxIJhLi7/dZjjtkWY9m781o7z9LiL/XYUbn5j6GeC67EXjEWtthrT0CHMTTniFtGOeAcG2noX5+hmU7GWPygGuBP/TZrDbyzai3U6gkpROBY31ulxHiX+j6sMCLxpitxpg7nA5mFOVYayvAcxIDsh2OZzR91hjzlncoWMgObTTGFADnABsJo/f7tOOGEH6/vcOqdgBVwGprbVi912EgnM/Nvhro7z3s287Hc0DYttMQPz/DtZ1+BnwFcPfZpjY6U3+5xKi3U6gkpaafbeFSVvgCa+0SPMOjPmOMucjpgCSgfgNMwzNcpwL4P0ejCRBjTBLwT+AL1tpGp+MZLf0cd0i/39babmvtYiAPWG6Mme9wSOJf4XxuHqmwbrshnAPCtp2G+PkZdu1kjLkOqLLWbvX1Kf1sC+k26mMouUTA2ilUktIyYFKf23lAuUOxjCprbbn3ZxXwBOEz1KDSGJML4P1Z5XA8o8JaW+k9EbmB3xOC77cxJhrPl5EHrbWPezeH/Pvd33GHw/sNYK2tB4rwzE8J+fc6jITtuXkIBvp7D9u2G+I5IGzbqYePn5/h2E4XADcYY47imTpwqTHmb6iNzjBALjHq7RQqSelmYIYxZooxJgbPBNynHI4p4IwxicaY5J7fgSuBXWd/Vsh4CrjV+/utwJMOxjJqej4gvN5JiL3fxhgD/BHYa639SZ+7Qvr9Hui4Q/n9NsaMM8akeX+PBy4H9hHi73WYCctz8xAN9Pf+FHCLMSbWGDMFmAFsciC+UTWMc0C4ttNQPz/Drp2stXdZa/OstQV4PntestZ+CLXRKc6SS4x6O0X5YydOs9Z2GWM+C7wARAL3W2t3OxzWaMgBnvB8hhMFPGStfd7ZkPzPGPMwUAhkGWPKgG8D9wCPGWNuB0qB9zgXYWAMcNyFxpjFeIZKHAU+6VR8AXIB8GFgp3euDMDXCf33e6Djfn8Iv9+5wAPeqn0RwGPW2qeNMa8T2u912Ajjc3O/hnIus9buNsY8BuzBU5H2M9babkcCH11DOgeEcTsN6fMzjNupP/pbOlW/uYQxZjOj3E7G2nAZLi0iIiIiIiLBJlSG74qIiIiIiMgYpKRUREREREREHKOkVERERERERByjpFREREREREQco6RUREREREREHKOkVERERERERByjpFREREREREQco6RUREREREREHPP/AXjKWxn4Vk4eAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 30001/30001 [03:00<00:00, 166.01it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score: 284.6333333333333\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(ENV_NAME),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score:', final_score)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state = env.reset()\n",
    "    reward = 0\n",
    "    while True:\n",
    "        qvalues = agent.get_qvalues([state])\n",
    "        action = qvalues.argmax(axis=-1)[0]\n",
    "        state, r, done, _ = env.step(action)\n",
    "        reward += r\n",
    "        if done:\n",
    "            print('Got reward: {}'.format(reward))\n",
    "            break\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got reward: 236.0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/6_5/'\n",
    "env = make_env(ENV_NAME)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dueling DQN\n",
    "\n",
    "In this approach as discussed in paper, https://arxiv.org/pdf/1511.06581.pdf , we replace the network. Our DQN and DDQN network was predicting Q values for all the actions in a given state. Instead of that, we will now predict two separate values, one for V(s), a scalar value and A(s,a) - advantage of a given action over V(s). Using these two, Q(s,a) is computed as below:\n",
    "\n",
    "$$ Q(s,a) = V(s) + [A(s,a) - \\frac{1}{|A|} \\sum_{a} A(s,a)] $$\n",
    "\n",
    "![Dueling DQN](./images/dueling_network.png \"Dueling DQN\")\n",
    "\n",
    "Training can be performed using either vanilla DQN or using DDQN approach. For demonstration purposes we will stick to vanilla DQN approach \n",
    "\n",
    "Code of Dueling DQN and associated code for training is given following cells"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DuelingDQNAgent(nn.Module):\n",
    "    def __init__(self, state_shape, n_actions, epsilon=0):\n",
    "\n",
    "        super().__init__()\n",
    "        self.epsilon = epsilon\n",
    "        self.n_actions = n_actions\n",
    "        self.state_shape = state_shape\n",
    "        \n",
    "        state_dim = state_shape[0]\n",
    "        # a simple NN with state_dim as input vector (inout is state s)\n",
    "        # and self.n_actions as output vector of logits of q(s, a)\n",
    "        self.fc1 = nn.Linear(state_dim, 64)\n",
    "        self.fc2 = nn.Linear(64, 128)\n",
    "        self.fc_value = nn.Linear(128, 32)\n",
    "        self.fc_adv = nn.Linear(128, 32)\n",
    "        self.value = nn.Linear(32, 1)\n",
    "        self.adv = nn.Linear(32, n_actions)\n",
    "                \n",
    "    def forward(self, state_t):\n",
    "        # pass the state at time t through the newrok to get Q(s,a)\n",
    "        x = F.relu(self.fc1(state_t))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        v = F.relu(self.fc_value(x))\n",
    "        v = self.value(v)\n",
    "        adv = F.relu(self.fc_adv(x))\n",
    "        adv = self.adv(adv)\n",
    "        adv_avg = torch.mean(adv, dim=1, keepdim=True)\n",
    "        qvalues = v + adv - adv_avg\n",
    "        return qvalues\n",
    "\n",
    "    def get_qvalues(self, states):\n",
    "        # input is an array of states in numpy and outout is Qvals as numpy array\n",
    "        states = torch.tensor(states, device=device, dtype=torch.float32)\n",
    "        qvalues = self.forward(states)\n",
    "        return qvalues.data.cpu().numpy()\n",
    "\n",
    "    def sample_actions(self, qvalues):\n",
    "        # sample actions from a batch of q_values using epsilon greedy policy\n",
    "        epsilon = self.epsilon\n",
    "        batch_size, n_actions = qvalues.shape\n",
    "        random_actions = np.random.choice(n_actions, size=batch_size)\n",
    "        best_actions = qvalues.argmax(axis=-1)\n",
    "        should_explore = np.random.choice(\n",
    "            [0, 1], batch_size, p=[1-epsilon, epsilon])\n",
    "        return np.where(should_explore, random_actions, best_actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#setup some parameters for training\n",
    "timesteps_per_epoch = 1\n",
    "batch_size = 32\n",
    "total_steps = 3 * 10**4\n",
    "\n",
    "# set exploration epsilon \n",
    "start_epsilon = 1\n",
    "end_epsilon = 0.05\n",
    "eps_decay_final_step = 2 * 10**4\n",
    "\n",
    "# setup spme frequency for loggind and updating target network\n",
    "loss_freq = 50\n",
    "refresh_target_network_freq = 100\n",
    "eval_freq = 1000\n",
    "\n",
    "# to clip the gradients\n",
    "max_grad_norm = 5000\n",
    "\n",
    "#set up random numbers\n",
    "seed=0\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed) \n",
    "\n",
    "#init environment\n",
    "ENV_NAME = 'CartPole-v1'\n",
    "env = make_env(ENV_NAME, seed)\n",
    "state_dim = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "\n",
    "#init agent, target network and Optimizer\n",
    "agent = DuelingDQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network = DuelingDQNAgent(state_dim, n_actions, epsilon=1).to(device)\n",
    "target_network.load_state_dict(agent.state_dict())\n",
    "optimizer = torch.optim.Adam(agent.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "buffer size = 10000, epsilon = 0.05000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAE/CAYAAAC+Q2VKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAB7/0lEQVR4nO3dd3gc1dn38e9R71aXi+TecG/YBhuw6b2E3gKkQAKEJA8pJHlSeUlIfUJCGiSUAAmYFkroBgE2GPde5S7ZlixZvWv3vH/sypZtyVpJuzvS7u9zXVzanZ1yz1kzs/ecZqy1iIiIiIiIiDghwukAREREREREJHwpKRURERERERHHKCkVERERERERxygpFREREREREccoKRURERERERHHKCkVERERERERxygpFelDjDH5xpgvOR1HVxlj/mqM+aGf93mrMWaRP/cpIiK+CeY12Bgz1BhjjTFRHXz+fWPM34MRS1cZY+4wxvze6ThOpLf8tjDG/MQY87T3dY4xZpMxJtbpuCQ4lJSK44wxu4wxTcaYzGOWr/behIY6FJr4ibX2K9ba+52OQ0QkHBljatr85zbG1Ld5f6M3GWg2xlR7/9tqjHnYGDPA6dh9Ya39ubW206Qq2MmXMSYG+F/g18E6ZmfaJn69mbW2GPgAuN3pWCQ4lJRKb7ETuL71jTFmIhDvXDhHdPRkNsDHNMYYx/7/dOKcRUQkMKy1Sa3/AXuAS9ose8a72nPW2mQgHbgC6A+s6CuJaaB18758GbDZWlsUiJjCwDPAHU4HIcGhpFR6i6eAz7d5fwvwz7YrGGNijTG/McbsMcYUe5uExns/SzPGvG6MOWiMKfe+zm2zbb4x5n5jzGLvU+B3jq2ZbbPuPGNMoTHmu8aYA8DjxpgIY8x9xpjtxpgyY8wCY0y6d/0njTH3el8P8tbu3ul9P9IYc8h7M/MlxgeMMYuBOmC4MeYcY8xmY0ylMeZhwHRUgN6nny8YY57znuNKY8zkNp8PNMa86D3+TmPMPe1s+7Qxpgq4tZ39n6j8W8vs+8aYUm/t941ttn3CGPP/vK8zvede4S2bj1tv9MaYk7zlUGGM2WCMubTNPjKMMa8aY6qMMUuBEcfEN9YY8653n1uMMdd0VFYiItI+a22ztXYDcC1wELjXl+2MMacaY5Z571fLjDGntvnsVmPMDu+9aWfr/cF7j/zQu02pMea5Tg5zo/ceVGqM+UGb/bdt9hnnvZeVee8ly4ynKegDwGnAw8ZTQ/ywD3Efe1++1xiz4pjzvtcY858O4r0A+LDNuu3G1uZY/88Y84k3vte8971nvPe9ZaZNy7FO4h7ovV8eMsYUGGO+7F1+PvB94FrvMda0iXWI6eA3kjFmtjeuCmPMGmPMvGPKqMPfV51sO8z7/VcbY94Fjv1d9hme30JDOihfCSFKSqW3WAKkeJOSSDw3w2Obl/wSGA1MAUYCg4AfeT+LAB4HhgCDgXrg4WO2vwG4DcgGYoBvnSCe/nieFg/B03TkHuBy4AxgIFAO/Mm77ofAPO/rM4Ad3r8ApwMfW2utjzHe7D1eMlAJvIin6U8msB2Yc4KYwfNU9nlv7P8C/mOMifYmfa8Ba/CU21nAN4wx5x2z7QtAKp6nk8c6UfmDp8wyvctvAR4xxoxpZz/3AoVAFpCD5wZpjTHR3hjfwfMdfQ14ps0+/gQ0AAOAL3j/A8AYkwi86z3nbDy17n82xozvsKRERKRD1loX8AqeRO6EjOch7X+BPwAZwO+A/3qTqkTv8gu8NbGnAqu9m96P55qfBuQCf+zkUHOBMXjuYT8yxpzUzjq3AP2APG8sXwHqrbU/AD4G7vbWEN99orjb7K/tffkPwLBjjnsTngfr7ZkIbOkstjafX+c93iA8D14/xfO7IR3YBPwYTlze3v38G899diBwFfBzY8xZ1tq3gJ/jqRVPstYefnBNB7+RjDGDvMf6f944vgW8aIzJ8sO2/wJW4PntcL+3fA6z1rYABUDbOCVEKSmV3qS1tvQcYDNwuLmLMcYAXwa+aa09ZK2txnNhvQ7AWltmrX3RWlvn/ewBjiSGrR631m611tYDC/AkVx1xAz+21jZ6178D+IG1ttBa2wj8BLjKeJq5fgic5k38Tgd+xZHk8Qzv577G+IS1doP3QnwBsNFa+4K1thn4PXCgkzJc0Wb93wFxwGzgZCDLWvsza22TtXYH8Ghr+Xl9aq39j7XW7T3nwzor/zZ+6C2zD/HciNqrrWzGk1gO8T6Rb03aZwNJwIPeGN8HXgeu9z6ouBL4kbW21lq7HniyzT4vBnZZax+31rZYa1fiSeiv6qS8RESkY/vwJBOduQjYZq19ynsN/jee+/gl3s/dwARjTLy1dr+3JhY894MhwEBrbYO1trOBk35qra231q7B85C1vWSlGU+iNtJa67LWrrDWVnUzbmhzX/be/5/Dk4jiffA5FM+9qj2pQHUXYnvcWrvdWlsJvAlst9a+5/1N8DwwtbO4jTF5eJL373rLdDXwdzzJ7ol09BvpJuANa+0b3t8H7wLLgQt7sq0xZjCe3yatvxs+wvNg+ljV3nKUEKekVHqTp/A8bbuVY5ru4qlVS8DTv6XCGFMBvOVdjjEmwRjzN2PMbuNpfvoRkOpNZlq1Tejq8CRAHTlorW1o834I8HKbY28CXECOtXY7UIPnInwanpvTPm8N3+Gk1McY97Z5PbDte2/i1vbz9rRd382RJ6VDgIGt8XvP4ft4airbO/axTlj+XuXW2to273d7j32sX+N58vmO8TTnus+7fCCw1xt3230M8h4n6pgYd7d5PQSYdcz53Yin9lZERLpnEHDIh/UGcvQ1Ge/7Qd77wrV4agX3G2P+a4wZ613nO3i6pSw1ni4bX+DEfLmPPwW8DTxrjNlnjPmVtyVOl+Ju8/7Ye+OTwA3eh7U3Awu8yWp7yvHUsPoaW3Gb1/XtvG893xPFPRBofXjc0Tm1p6OyHQJcfcz9dS6eh8s92XYg7f9uOFYyUNFJ7BIClJRKr2Gt3Y1nwKMLgZeO+bgUzwV5vLU21ftfP+sZtAE8TULHALOstSl4aizhBH0wOwvnmPd78TQ9Sm3zX5w9MnjBh3hq5WK8yz7EU+ubxpFmSr7E2Pa4+/E08fGs5LkB5nFibdePwNMcap83/p3HxJ9srW37pPPYc26rs/IHSPM202o12Hvso1hrq62191prh+N5Gv0/xpizvOvmmaMHkhiMp8b8INByzPkPbvN6L/DhMeeXZK396gnOSUREOuC9Fl+Cp8lrZ/bhSUDaar1+Y61921p7Dp5kZDOeljpYaw9Ya79srR2Ip0XSn40xI3sSt7cFzk+ttePwNBW+mCNjVhx7nzth3O1tY61dAjTheQh9Ax033QVYi6fbiy+xdcWJ4t4HpBtjktv5DE58r2/PXuCpY+6vidbaB3u47X7a/91wmLc12kg8teIS4pSUSm/zReDMY56ctdb6PQr8nzEmGw4PKtTaJzIZT9JU4e1r8WM/x/VX4IHWzvbGmCxjzGVtPv8QuBtP7SdAPp4+kYusp19Od2L8LzDeGPM574X5Hjqv+ZveZv1vAI14+usuBaqMZ/CmeGNMpDFmgjHm5E7PHJ/Kv9VPjTExxpjT8Nxsnz92X8aYi41ncAsDVOGpcXbhGdCgFviOtx/sPDw/iJ71luFLwE+8Nc7jOLrvyevAaGPMzd5to40xJ3fQ30hERDrgvX6ehKdfYn88XUE68waea/ANxpgoY8y1wDjgdeMZZOhSb/LRiKdlkct7rKvNkQH/yvEkTK529t+V+OcbYyZ6WyFV4Wky27rPYmC4L3F3cph/4hkToqWTJsdv0KabTiexdUWHcVtr9wKfAL8wnoGVJuH5bdU6VkQxMNT4PpLw03iaBZ/n/e0QZzyDG+Z2uuUJtvVWRCznyO+GuRzdbBpgJp6uOe3VoEqIUVIqvYq3L8XyDj7+Lp5mn0u8zV/fw1PzCJ7+lvF4avSW4Gla6k8PAa/iaXJa7T3GrDaff4gn6WxNShfhae76UZt1uhSjtbYUuBp4ECgDRgGLO4nzFTzNpMrxNCv6nPfJrAvPxX4KntroUjx9TPp1sr+2TlT+4Gm+U47nKe0zwFestZvb2c8o77Y1eAZx+LO1Nt9a2wRciqcvbSnwZ+DzbfZxN54mQQeAJ/AM/gB4al+Bc/H0cd3nXeeXgCbdFhHxzbXGmBo8TSVfxXPfmW6tPa7Fy7GstWV4HkTe693uO8DF3vtYhHf5PjxNgc8A7vRuejLwmfe4rwJft9bu7OF59MczaF8Vnq42H3Jk4MSH8IwHUW6M+UMncZ/IU8AETlxLCp4+kmONMa1dWU4Um898iPt6PH1d9wEv4xkj413vZ60Pi8uMMSt9ONZePAMhfh9Pq6W9wLfxIYfwYdsb8PyWOoTnQf2xXbduxFMpIGHAeLqpiUhfZ4z5CZ7BE25y4NjzgKettb48ORUREemzjGc6tBJgmrV2Wyfr3g6Ms9Z+IxixhQpvq6wPganHjPEhISrK6QBERERERPqQrwLLOktIAay1jwQhnpBjrS0B1AUnjCgpFRERERHxgTFmF54BCi93NhKR0KLmuyIiIiIiIuIYDXQkIiIiIiIijlFSKiIiIiIiIo7pFX1KMzMz7dChQ/2yr9raWhITEztfMYSE4zlDeJ53OJ4zhOd5h+M5g//Oe8WKFaXW2iw/hBS2dG8OLpWRb1ROvlE5dU5l5Bt/ltOJ7s29IikdOnQoy5d3NDVl1+Tn5zNv3jy/7KuvCMdzhvA873A8ZwjP8w7Hcwb/nbcxRpOt95DuzcGlMvKNysk3KqfOqYx8489yOtG9Wc13RURERERExDFKSkVERERERMQxSkpFRERERETEMUpKRURERERExDFKSkVERERERMQxSkpFRERERETEMUpKRURERERExDFKSkVERPoYY8xjxpgSY8z6NsvSjTHvGmO2ef+mtfnse8aYAmPMFmPMec5ELSIi0j4lpSIiIn3PE8D5xyy7D1horR0FLPS+xxgzDrgOGO/d5s/GmMjghSoiInJiSkp7me0Ha9h7qM7pMEREpBez1n4EHDpm8WXAk97XTwKXt1n+rLW20Vq7EygAZgYjTpHe4EBlA6+sLqK8tsnpUESkA1FOByBH++Zzq8lMiuWxW092OhQREelbcqy1+wGstfuNMdne5YOAJW3WK/QuO44x5nbgdoCcnBzy8/P9ElhNTY3f9hWqVEa+6U45/W55A2tLXVwyIporR8UEJrBeRv+eOqcy8k2wyklJaS+zq7SWpha302GIiEjoMO0ss+2taK19BHgEYMaMGXbevHl+CSA/Px9/7StUqYx8051yenD1R0A10SnZzJs3JRBh9Tr699Q5lZFvglVOar7bi1Q1NFPV0EKZmpeIiEjXFRtjBgB4/5Z4lxcCeW3WywX2BTk2Ece0/q46UNXgcCQi0hElpb1IUXk9AIdqm3C7232ILSIi0pFXgVu8r28BXmmz/DpjTKwxZhgwCljqQHwiQWetPdyXtFhJqUivpea7vUhrUupyW8rrmshIinU4IhER6Y2MMf8G5gGZxphC4MfAg8ACY8wXgT3A1QDW2g3GmAXARqAFuMta63IkcJEeqG5opra5aw/tq+pbaPE+6C+uagxEWCLiB0pKe5GiivrDr0trlJSKiEj7rLXXd/DRWR2s/wDwQOAiEvGvhZuKWb23gsumDKRffAyPfryDRz7awUnpEVx0ju/7Ka31JKJj+yez+UA1NY0tJMV6fv6u2F1OZlIMQzIS/Rr7/a9vZO+hOh75/IzDy9xuiwUiI9rr4i0iSkp7kaOT0kbGkOxgNCIiIiLO+OF/1rOvsoE/vl9w1PJNh9xYazGm4+SutKaRN9cf4KZZgznkbbo7bmAKmw9Uc97/fcQFE/pTWF7PWxsOMCwzkQ++Nc+vsf9j0U7AM83fiKwkAH7zzhae/GQXf75pOmeMzvLr8URCgfqU9iKF5XVER3ousqU1amIiIiIi4ammsYUzx2bz7fPGcOupQ3n81pO5//IJQOcDFn37+TX88D/r2bCvivtf3wjA3JGZgKeP6eOf7GJNYQUAO0tr2XGwxq+xt9bEnvXbD/l/r29k5Z5ynvlsD7VNLr7y1Aq/H08kFKimtBcpKq9n3IAU1hRWUlqjEXhFREQkPNU1uRjTP5m75o88vOzT7WUA/HftflbvrWD6kDRumzPsuG33V3qS1qeX7GZtYSUAs4dnsO2BC4iOjKDF5SYqMoIdB2s4+3cfcv5DH7Pke2eRnuifOUyzkmOJiYpg7shM/rF4J3/31px+7cyR/PH9Aj7aepDh3hpUEfFQTWkvUlRRz0kDUoiKMKopFRERkbDU1OKmxW1JiI48avmoHE8i9//+u4nX1+7np69t5DsvrDlufvfoSM/P21dWH5n5KCMp5vDyKO/f4VlJ/PiS8TS1uA/XnPpDfZOLc07K4Q/XT2XF/57D/ZdP4IzRWXxhzjCiIw0HNOCSyHGUlPYSDc0uSmuayE2LJyMphtJqXbBEREQk/NQ3eQaHjo85OinNSIxh7qAo5ozM4B+3eAYRWrC8kOW7Dh21Xkm1p6a0vtlFXno8K394DrFRR++r1RXTBgGwcV+V3+JvaHERF+35iZ2eGMPNs4fw5BdmkpYYQ3ZynKamEWmHktJeonWQo9y0BDKTYlVTKiIiImGprrkFgMTYo3uZGWP40sRYnvnSbM46KYdnb58NwN7yuiPbNrUcNfXL2P4pJ2yWmxIXTV56PBv3+y8prW9yERfTfhLcv5+SUpH2qE9pL1HonaN0UFo8mUmxlNWqT6mIiIiEnzpvTWlCB4ldqxlD0oiKMOw5dCQp/XDLQQB+fMk4Nu6r4tIpAzs93kn9U/xWU+p2Wxpb3MR1UDObkxLL5gPVfjmWSChRUtpLFLUmpamepHRbsS5YIiIiEn7qGr3Nd6NPnJRGRUYwKC2eNXsr+fkbmyipauDjbaWMzE7i5tlDDvcd7cyUwam8s7GY8tom0no42FGjt3/rsU2PW+WkxPHR1tIeHUMkFKn5bi9RVFFHVIQhJyWOzOQYSmuasNY6HZaIiIhIUNU1eZrvJsR0XneSlhDDooJSHlu0k5V7Khg3MIU/XDfV54QUYPrgNABW7invXsBt1Dd7Euq4qPaP3z8ljprGFva1mZteRJSU9hpF5fX07xdHZIQhMzGWJpebqoYWp8MSERERCao6b2KXEHvimlKAvPQEAJ764iw++s58nvriLMYNTOnS8SblpmIMfPHJ5WzYV9n1gNtoaG5/kKZWs4ZnEB1p+MZzq3t0HJFQo6S0lyiqqGdQajwAmcmepiMa7EhERETCTb2PfUoBfnLJOF69ew6njMjo9vHiYyL51rljALjvxXU9aql2uKa0g6bHU/JSuWTywMPdtkTEQ0lpL1FYXk9umudpX2ZSLABlNRrsSERERMLL4YGOojtvvpuRFMuk3NQeH/Ou+SP56aXjWVdUyd5D3U8YWxPqjpJSgNioyMN9T0XEQ0lpL9DsclNc1cCgNG9NqTcpVU2piIiIhJvWPqUdNYENlLH9kwHYfai22/tobOl8kKbYqIjD64mIh09JqTFmlzFmnTFmtTFmuXdZujHmXWPMNu/ftDbrf88YU2CM2WKMOS9QwYeKA5UNuC3kpiopFRERkfDm65Qw/jY0MxGAXaXdT0rrmzw1oCeuKY2gSTWlIkfpSk3pfGvtFGvtDO/7+4CF1tpRwELve4wx44DrgPHA+cCfjTHBvar0MW3nKAVIS4jGGCitVlIqIiIi4aU1Ke1sShh/y06OJS46gl1ldZ2v3IHWPqWd15S6NcuCSBs9ab57GfCk9/WTwOVtlj9rrW201u4ECoCZPThOyCuqODJHKXjm3UpPiOGg+pSKiIhICCuraeRQ7dG/d+qbWoiPjiQiwgQ1FmMMQzMS2V3W/ZrSI6PvdvwTO9absDa7lJSKtOq8B7mHBd4xxljgb9baR4Aca+1+AGvtfmNMtnfdQcCSNtsWepcdxRhzO3A7QE5ODvn5+d07g2PU1NT4bV/BsrigCQNsW7uUXd4LcLxpZsuuIvLzyzrdvi+esz+E43mH4zlDeJ53OJ4zhO95i4Sr6f/vPSIM7PjFRYeXVdW3BL3pbqux/ZN5b1MJ+VtKGJGVdHjKGV+11pTGRnUcf4x3DtXGFhcxHcxnKhJufE1K51hr93kTz3eNMZtPsG57j7WOexTkTWwfAZgxY4adN2+ej6GcWH5+Pv7aV7D89+AaslMOcs6Z8w8vG1KwhPomF/Pmzel0+754zv4QjucdjucM4Xne4XjOEL7nLRKOWpuvuq3ntTGGbcXVvLy6iNNGZjoS07fOG8OHWw9y6+PLiIuOYOUPzyEhxrefy263ZdnOQ8CJB2mKjW5NSt0k9zxkkZDg0+MZa+0+798S4GU8zXGLjTEDALx/S7yrFwJ5bTbPBfb5K+BQ1HaO0laZSbGUqvmuiIiIhKjW7ksAH2wp4aWVhXy8rZSmFjf3Xz7BkZhy0xJYeO88PjdtEA3NbgpKanze9oevrOf5FYXAiQc6aq0p1WBHIkd0mpQaYxKNMcmtr4FzgfXAq8At3tVuAV7xvn4VuM4YE2uMGQaMApb6O/BQUlRRz6C0o5uHZCTGavRdERERCVnbio8kfF94Yjn/s2ANy3YdIjk2igH94hyLKz0xhrvmjwRga7FvSanLbfn30j2H359woKM2NaUi4uFLe4Qc4GVjTOv6/7LWvmWMWQYsMMZ8EdgDXA1grd1gjFkAbARagLustZqMqQNut2V/RQMXTDimpjQ5hromF3VNLT43GxERERHpC6y1vLyq6Ljlb64/wMRB/fD+7nTMkPQEYqIi2Fpcze6yWnYcrGX+2OwO1y+racRt4f7LxnPp5EFEnmCQptb+pqopFTmi02zHWrsDmNzO8jLgrA62eQB4oMfRhYGDNY00udyHp4Np1TpXaVlNEwnpSkpFREQkdKzcU8Gra/Zx46zB3HPWKPrFR3P5nxaz+UA1QzK6NrhQIERFRjAiK4lHPtrBIx/tAODZ22cze3hGu+sXV3lat2WnxNEvIfqE+2470JGIeGjIL4cVlnvmwso9JinN8ialB9WEV0REREJMVUMzAFdOzyUnJY646Eiump4LQLOrd9Qg3nfBWL40dxjXzsgjwsBXn17Bj15Zz9m/+5BfvLnpqHVLqhsAz1ynnWltvquaUpEjVAXnsMJyTyf/3HYGOgIorVZSKiIiIqGlock7n2ebvpdXz8jjtTX7+MKcYU6FdZQzRmdxxugsAO44Yzhff3Y1/166h2aXpaCkhq+dOYqkWM9P6daa0pyUzvvCHqkpVVIq0kpJqcNaR547tvluRlIMgEbgFRERkZDTOp9n26S0X3w0r9w916mQTmh4VhKvfW0utY0trNpTwU3/+IwLH/qYmcPSuWHW4MM1pa2VCicS6z1nNd8VOUJJqcOKyutJS4g+bjCjI0mpakpFREQktDQ0e2oJTzSfZ2+UGBvF3FGZ/PqqSby0soh3Nxbz+tp9tLgs/eKjiYnqvGecpoQROZ6SUod5poOJP255bFQkKXFRlCkpFRERkRDTWlMaF9W3ktJWV8/I4+oZeZTWNPLlfy5n1Z4Knwdo0pQwIsdTUuqwwvJ6RmYltftZZnKsmu+KiIhIyGloTUpj+vaYm5lJsTx/xyms2F3OwNTjKxnaExulpFTkWH37StDHWWspKm+/phQ8FzqNvisiIiKhpqHZRYQ50pS1L4uKjGDW8Azy0n2rKY1RUipynL5/JejDyuuaqW92MaiDJ2tZSbHqUyoiIiIhp77JRVx0JMYYp0MJulhvk2X1KRU5Qkmpg4rK2x95t1VGUoymhBEREZGQU9/sOmrk3XBypPmuRt8VaaWk1EFFFXUAHdaUZibFUtXQoouWiIiIhJSGZjdxYZqUHp6ntFk1pSKtlJQ6qNBbU5p7gj6lAIdqNdiRiIiIhI6GZhdx0eH5MzQiwhAdaWhyKSkVaRWeV4NeorC8nqTYKPrFR7f7eWbrXKXVSkpFREQkdNQ3u/rcHKX+FBsVqZpSkTaUlDqoqKKeQanxHXbyz0z21JRqsCMREREJJQ1h3KcUIDUhmrc3HODT7WVOhyLSKygpddCJpoMByEz0JKWaFkZERERCSX2zK2z7lAL8/topREUabvz7Ej7YUuJ0OCKOU1LqoNaa0o5kJnub7yopFRERkRDSOiVMuJoxNJ037jmNoZmJ/P69bU6HI+I4JaUOqW5oprK++YQ1pQkxUSTERFJWoz6lIiIiEjoaW9xh3XwXIDE2ism5qRyqVeWDiJJShxRVeOcoPUFNKXhG4FVNqYiIiIQST02pfoamxEVRVd/idBgijtPVwCFFnUwH0yozKUZJqYiIiISU+jAf6KhVSnw01Q3NuN3W6VBEHKWk1CGHa0o7SUozkmI1JYyIiIiEDGtt2A901ColLhq3hdom1ZZKeFNS6pCi8npioiIOj7DbETXfFRGRrjDGfNMYs8EYs94Y829jTJwxJt0Y864xZpv3b5rTcUr4qqpvoanFTVbyiX8DhYOU+CgAqhqUlEp4U1LqkMJyz8i7ERHtz1HaKisphkN1TbjUrENERDphjBkE3APMsNZOACKB64D7gIXW2lHAQu97EUe0thYb2Mm4GuEgJS4agKr6ZocjEXGWklKHFHYyHUyrzORYrIVDtWrCKyIiPokC4o0xUUACsA+4DHjS+/mTwOXOhCYC+3wc7DEcpMQrKRUBJaWOKSqv73SQI/A03wVn5yr9wcvreHlVoWPHFxER31hri4DfAHuA/UCltfYdIMdau9+7zn4g27koJdyppvSIwzWlar4rYS7K6QDCUUOzi9KaRp+eEGYkxgDOJaUl1Q0889keCkpquGJqriMxiIiIb7x9RS8DhgEVwPPGmJu6sP3twO0AOTk55Ofn+yWumpoav+0rVIVTGS3Z0kRUBKxb/gkR5sTdmI4VauVUUucGYOmqtUSXRPttv6FWToGgMvJNsMpJSakD9vk48i54mu+Cc0npJwVlAKwrqqTF5SYqUpXrIiK92NnATmvtQQBjzEvAqUCxMWaAtXa/MWYAUNLextbaR4BHAGbMmGHnzZvnl6Dy8/Px175CVTiUUUOziz/nb+fNndsYmpHAmfPnd3kfoVZO5bVN8NG7DBw6ksGjsyirbWLGkDRMF5P1Y4VaOQWCysg3wSonJaUOKOpCX4rW5rtlNc70KV1UUApAXZOLrcU1jBuY4kgcIiLikz3AbGNMAlAPnAUsB2qBW4AHvX9fcSxCCVt3PrOSD7aUMCm3HxdPGuB0OL1Ccpznp/hPX9t4eNn9l0/g5tlDnApJxBFKSh1QWO57TWlKXBQxkREcdKCm1FrL4oJSJgxKYX1RFav2lispFRHpxay1nxljXgBWAi3AKjw1n0nAAmPMF/Ekrlc7F6WEq892lHHDzME8cMVEp0PpNaIiI5g/JovPdh6iscWNy20prmxwOiyRoFNS6oCi8noiIwz9U+I6XdcYQ2ZSDKXVwa8p3X6wlv2VDdx95kh++85WVu+p4MZZenInItKbWWt/DPz4mMWNeGpNRRxhraWu2UW6d6wMOeLx22bS0Oyisr6ZM3+TT32zy+mQRIJOHQQdUFRRT/+UOJ/7Z2YkxTrSp3Sxt+nuaSOzmJKXyqq9FUGPQURERPq+xhY31kJ8TKTTofRKcdGR5KTEER8TqaRUwpKSUgcUldf71HS3VWZSjCNJ6cfbShmcnsDgjASm5qVSUFJDpebREhERkS6qb/IkWgnRSkpPJC46koYmJaUSfpSUOqCoop7cLszNlZkUG/SBjlpcbpbsKGPOyEwApgxOBWBtYUVQ4xAREZG+r85b+6ea0hNLUE2phCklpUHW7HKzv7KLNaXJsZTVNmKtDWBkR1tTWEFNYwunjfIkpZPzUjEGVu+pCFoMIiIiEhrqm1oAiI/RcCYnEh+tpFTCk5LSIDtQ2YDb+jYdTKvMpFiaXTaoTWcXbSvDGDhleAYAKXHRjMhKUr9SERER6bL6Jjeg5rudiYuOPNzUWSScKCkNstY5SnPTEnzeJjPJM1JdMPuVLio4yMRB/UhrM0re1LxUVu+tCGqNrYiIiPR9dYdrSpWUnkh8TCQNqimVMKSkNMiKujBHaavMpFgADgZpWpiaxhZW7ak43J+01dTBaRyqbWLPobqgxCEiIiKhQX1KfaPmuxKulJQGWWtN6YB+nc9R2qo1KS2rDU5N6Wc7ymhxW047JimdkpcKwCr1KxUREZEuaB1RNkFJ6QkpKZVwpaQ0yArL68hKjiWuC30qDjffrQ5OUrqooJTYqAimDUk7avnonCQSYiJZrX6lIiIi0gV13qQ0Xn1KTyguJvJw/1uRcOJzUmqMiTTGrDLGvO59n26MedcYs837N63Nut8zxhQYY7YYY84LROB9VVFFfZcGOQJIS4ghMsJQGqRpYRZtK2XmsPTjEueoyAgmDurHqj3lQYlDREREQoOa7/omPlp9SiU8daWm9OvApjbv7wMWWmtHAQu97zHGjAOuA8YD5wN/NsboCuRVVN616WAAIiIM6YkxQRnoqLiqgW0lNcw9puluq6mD09i4v0oXTBEREfHZkea7mhLmRFqb72pQSQk3PiWlxphc4CLg720WXwY86X39JHB5m+XPWmsbrbU7gQJgpl+i7ePcbsu+igZyu5iUAmQEKSldtK0UgLmj2k9Kp+Sl0uyybNhXFfBYREREJDSo+a5v4mMicbktzS4lpRJefH1c9XvgO0Bym2U51tr9ANba/caYbO/yQcCSNusVepcdxRhzO3A7QE5ODvn5+V0KvCM1NTV+25e/VTS4aXK5qTtYSH5+cZe2jWyuZ8e+2nbPzZ/n/OLaRpJjoHjLSg5uNcd9Xt/g6efwwgfLqR4a7Zdjdldv/q4DJRzPGcLzvMPxnCF8z1sk1NU3u4iJiiAy4vjfFnJEa9LeWl4i4aLTpNQYczFQYq1dYYyZ58M+27vaHPe4x1r7CPAIwIwZM+y8eb7sunP5+fn4a1/+tmJ3OeR/wvyZk5g3NqdL275SvJpluw61e27+OmdrLd9ZvJB5J2Vz5vypHa73m9XvUx2Tyrx503p8zJ7ozd91oITjOUN4nnc4njOE73mLhLr6phaNvOuD1j63Dc0u+sU7+/BfJJh8qSmdA1xqjLkQiANSjDFPA8XGmAHeWtIBQIl3/UIgr832ucA+fwbdV7VOBzMoNaHL22YmeZrvWmsxJjBPGbeV1FBS3cjckRknXG9KXqqmhREREZETqmtq4YlPdjFpUCo1jS413fXB4ZrSJo3dIeGl03YB1trvWWtzrbVD8Qxg9L619ibgVeAW72q3AK94X78KXGeMiTXGDANGAUv9HnkfVFTuTUq70ac0MymWhmY3tQG8SB3pT5p1wvWmDk6lqKKekuqGgMUiIiIifdtD723jV29t4aZ/fMaLKwsPz7suHWud+aCmsYVX1+yjvDY4My+IOK0nQ6A9CCwwxnwR2ANcDWCt3WCMWQBsBFqAu6y1etwDFFXUkZoQTVJs14s9w3shL61u7Nb2vlhUUMqwzMROp6yZkpcKwOo9FZw7vn9AYhEREZG+bVdZLQkxkUwY2I8BqXHcNX+k0yH1esOzEjEGLv7jIgC+fd4YlZuEhS5lN9bafCDf+7oMOKuD9R4AHuhhbCGnqLzrc5S2ykyKAaC0ppGhmYn+DAuAZpebJTvKuHJabqfrThjUj6gIw+q9SkpFRESkfeV1zUwY1I8Fd5zidCh9xuicZJ67/RSeXbqHl1YVUVylVmkSHjRZVBAVltczrJsJZWuTl9KawDTjWLWngromF3M6mJ+0rbjoSE4akKJ+pSIiItKhirqmbv/uCWczh6Uzc1g6mw5UH+76JRLqNNZ0kFhrKaqo71Z/UoCs5NakNDBzlS4qKCXCwCkjTjzIUaupg1NZW1iBy615tEREROR45XXNpCXEOB1GnzUoNZ5CJaUSJpSUBklFXTN1Ta5uN99NTzzSfDcQFm07yKTcVJ+HH586OJXaJhfbSqoDEo+IiIj0XdZaKuqaSFVS2m25afEUVdRjrSoAJPQpKQ2S1ulgcrtZUxodGUFqQnRAktKqhmbWFFZy2qjOm+62mpKXBngGOxIRERFpq7bJRbPLkpaguTa7KzctnprGFirrm50ORSTglJQGSWvzi9y0rs9R2iozKZbSav/3KV2yvQyX2/rUn7TV0IwEUhOi1a9UREREjtM6lUlaompKuysnJQ6AkurAtJIT6U2UlAZJYXkdQLeb74JnBN6yWv9fmBYXlBIfHcm0wWk+b2OMYUpeKqv2lvs9HhEREenbKuo8tXvqU9p9CTGeOUvrAzhHvUhvoaQ0SIoq6kmIiSS1B81YMpNiAzL67scFpcwank5MVNf+OUzNS2NbSQ3VDWpWIiIiIkeU13lrStV8t9vio71JabOSUgl9SkqDpHWOUmNMt/fhab7r35rSfRX17DhYy9wuNN1tNWVwKtbC2sJKv8YkIiIifds7Gw8AR5qgStfFeWtKG5SUShhQUhokPZkOplVmUgzVjS1+vTgtKigFYG4XBjlqNSU3FYDVeyv8Fo+IiIj0bS+vKuTpJXv40txh5KV3fyyNcBcXpaRUwoeS0iApqqjv9si7rTKT/D9X6eKCUjKTYhmTk9zlbfslRDMiK5FVe9SvVERERGDzgSq+99I6Zg1L574LxjodTp8WH6PmuxI+lJQGQU1jCxV1zQxK7dnTwtaktMxP/UrdbsviglLmjszodrPiKXlprN5boTm0REREhBdXFOJ2w8M3TCMqUj8ze6K1T2lDs9vhSEQCT1eLICjyTgfT4+a7yf6tKd1SXE1pTRNzR2V1ex9TB6dSWtN0eMobERERCV/1zS6S4qLI8v5mke6Li/b8TNfouxIOlJQGQVFFz6eDAU+fUvBfUrpom7c/aTcGOWo1JS8VgJVqwisiIhL2GpvdxHZxNH9pX5xG35UwoqtGELTWlPqvT6l/mu8uKihlZHYS/ft1f2S8sf2TiYuO0GBHIiIiQpNLSam/xEZFYAw0KimVMKCrRhAUVtQTExlBVlLPmrLERUeSFBvFQT9MC9PY4mLpzkM9qiUFiIqMYNKgVFbtqehxTCIiItK3NTa7uzzvubTPGENcVKRqSiUs6KoRBEXl9QxMjSMiovtzlLbKTIqhrLbnNaUrd1dQ3+xiTg+TUvD0K924r4rGFl00RUREwpmnpjTS6TBCRnyMklIJD0pKg6CwvOdzlLbKTIql1A81pYsLSomMMMwent7jfU3JS6XJ5Wbjvqoe70tERET6rsYWl2pK/SguKkKj70pY0FUjCIoq6ns8yFGrzKRYvwx09HFBKVPyUkmOi+7xvqYOTgNQv1IREZEw19SiPqX+FKeaUgkTumoEWEOzi4PVjT2eo7RVZnJMj5PSyrpm1hVW9Lg/aav+/eIY0C9O/UpFRETCXGOL+pT6U3x0pAY6krCgq0aA7a9sAHo+R2mrjMRYyuuaaXZ1vynHpztKcVuYO8o/SSl4mvCu2qtpYURERMKZakr9Ky5aNaUSHnTVCLDW6WD81nzXOxl1eQ8GO1pUUEpiTOThOUb9YergVPYeqvfbHKoiIiLS93hqSjXQkb/ER0dS36SkVEKfktIAKyyvA3o+R2mrrKQYAA72IPlbtK2U2cMziI7039c/Jc/br1RNeEVERMJWY7NLNaV+FBcdqYGOJCzoqhFgRRX1RBhPv0t/yPTOdVpa072a0r2H6thVVufXprsAEwf1IzLCaLAjERGRMNbkUp9Sf4qLjqBBzXclDOiqEWBF5fX0T4nzW63k4aS0m9PC5G8pAeD00Vl+iadVfEwkY/snq1+piIjDjDGpxpgXjDGbjTGbjDGnGGPSjTHvGmO2ef+mOR2nhKbGZvUp9aeEmEh2lNby1JLdTociElC6agRYYYX/5igFyPA23+1u3833N5cwNCOBEVlJfoup1dTBqazZW4nLbf2+bxER8dlDwFvW2rHAZGATcB+w0Fo7CljofS/id42qKfWrm2cPBeDV1UXOBiISYLpqBFhRuf/mKAVIio0iNiqCsm4MdFTX1MLi7WWcOTbHb/G0NTUvjZrGFrYfrAnI/kVE5MSMMSnA6cA/AKy1TdbaCuAy4Envak8ClzsRn4Q2a6139F0NdOQvE3P78flThrBpfzVuPfSXEKakNIBaXG4OVDWQm+afOUoBjDFkJsV2q/nuJwVlNLW4OeukbL/F09aUwamABjsSEXHQcOAg8LgxZpUx5u/GmEQgx1q7H8D7NzA3AglrTd7p6tR8179OGpBCTWMLhd4ZHURCUZTTAYSykupGXG7LgFT/DHLUKjM5tluj7y7cXEJSbBQnD033azythmUk0i8+mlV7y7nm5LyAHENERE4oCpgGfM1a+5kx5iG60FTXGHM7cDtATk4O+fn5fgmqpqbGb/sKVaFQRnXNnpq8vbt2kp9fGJBjhEI5dVV9pWegowdfWMSFw6JJijGdbhOO5dRVKiPfBKuclJQGUHFVAwD9U/yblGYlxVBU0dClbay1vL+5mNNHZwasr0dEhGFyXiqrVFMqIuKUQqDQWvuZ9/0LeJLSYmPMAGvtfmPMAKCkvY2ttY8AjwDMmDHDzps3zy9B5efn4699hapQKKPSmkZY+B7jx45i3ilDA3KMUCinrjrNbfm0cgVvbCzmk2L40w3TmDPyxLMohGM5dZXKyDfBKie1rwigEm8T2xw/J6UZibFdHuhow74qiqsamT8msC22pualsrW4mprGloAeR0REjmetPQDsNcaM8S46C9gIvArc4l12C/CKA+FJiGts8TTf1UBH/hUZYfjbTdN59vbZZCfHctM/PuP2fy7XwJISUnTVCKASb01pdnKsX/ebmRzDodqmLnV4/2BzCcbAvAAnpVMGp+K2sLawIqDHERGRDn0NeMYYsxaYAvwceBA4xxizDTjH+17Er5paWvuUaqAjf4uIMMwensFLd85h5tB03tlYTGF5ndNhifiNktIAKq5qJMJARpKfk9KkWFxuS0V9s8/bLNxcwuTcVLL8nCAfa0puKgCr91YE9DgiItI+a+1qa+0Ma+0ka+3l1tpya22ZtfYsa+0o799DTscpoaexxdP3UTWlgZMUG8W3z/M0hNhRWutwNCL+o6tGAJVUN5CVHEtkROcd0rsi05vk+tqE92B1I2sKKzhrbOAHW0xLjGF4ZqL6lYqIiISZxmaNvhsMwzITAdh5UEmphA5dNQKouKqR7GT/9ieFNkmpj9PC5G8pwVo4M0BTwRxr6uA0lu86RLN3aHgREREJfct3lwOqKQ209MQYUuKi2KmaUgkhumoEUHFVAzkp/m8um5kUA+DztDDvby6hf0oc4wak+D2W9lw0qT/ldc0s3NTu4I4iIiISYuqaWrj/9Y0AxETq52UgGWMYlpXEsl2HqGvSwJISGnTVCKCD1Y1k+3nkXWjbfLep03WbWtx8vK2U+WOzMca/zYg7cvqoLHJSYnl++d6gHE9ERESctfdQ/eHXA1PjHYwkPHx+9hA2H6jmiU92OR2KiF90mpQaY+KMMUuNMWuMMRuMMT/1Lk83xrxrjNnm/ZvWZpvvGWMKjDFbjDHnBfIEequmFjdltU1+H3kXoF98NFERhjIfakqX7TpETWNLUPqTtoqKjOCq6bl8sKXk8FytIiIiErr2HvKMBPvCV04hLz3B4WhC35XTc0mOi6KkqmtTBIr0Vr7UlDYCZ1prJ+MZWv58Y8xsPJNxL7TWjgIWet9jjBkHXAeMB84H/myMCbuxwVub1vp7jlLwDAuekRTj00BHCzeVEBsV0ekky/529fQ83BZeWFEY1OOKiIiIf5XXNrFpf9UJ19nrnZ5kqHcQHgm8hJhI6ptcToch4hedJqXWo8b7Ntr7nwUuA570Ln8SuNz7+jLgWWtto7V2J1AAzPRn0H1B6xylgehTCp4mvJ0137XWsnBzMaeOyCA+JrjPBYZmJjJrWDrPL9+LtZrcWUREpC+qbWzhukeWcOEfPuYXb2xiZ2ktT326i688tYKiiiNNdvceqichJpKMxBgHow0viTFR1KpPqYQIn/qUGmMijTGrgRLgXWvtZ0COtXY/gPdva/vQQUDbzoSF3mVhpdjbnCIQo+9Ca1J64prSHaW17C6r48wgNt1t69qT89hVVsfSnZoOT0REpC9YuvMQ720sBjzzjn77hTVsK6nmnJNy+NtHO5j/m3x++MoG3tpwgLfXHwDgnQ0HeGzxTvLSEoI2foVAvGpKJYRE+bKStdYFTDHGpAIvG2MmnGD19q5Gx1WVGWNuB24HyMnJIT8/35dQOlVTU+O3ffXEot3NABSsX0HpNv+PJ9VS00jhIRf5+fkdnvNbOz0xxFfsID9/l99j6EyiyxIfBX94fTlfnuT/GuPe8l0D1DZbXtrWxLlDoslJDNz4Yb3pnIMpHM87HM8Zwve8RXqLO59ZSWlNI9fMyGXDvio27Kvi+xeO5fbTR7B6bwVr9lZw8tB0bn18Kev3VfLR1oPc/tQK+sVHc+mUgU6HH1YSYiKpU1IqIcKnpLSVtbbCGJOPp69osTFmgLV2vzFmAJ5aVPDUjOa12SwX2NfOvh4BHgGYMWOGnTdvXtejb0d+fj7+2ldPLH97C5FbtnPJOfOJjPD/U8NP6zax7JNdnHHGGXz44YftnvPfti5hbP8mrrrgdL8f31dXVK3jpZWF/HX2HJLjov26797yXTe1uLnlsaV8uqeOhLRs/njR1IAdq7ecc7CF43mH4zlD+J63SG/R+pNlwfJC4qIjePTzMzhnXA4AU/JSmZKXCsCEQf14aWURH28rZXhWIm/ccxpx0WE3hIij4mOiqKzrfCYGkb7Al9F3s7w1pBhj4oGzgc3Aq8At3tVuAV7xvn4VuM4YE2uMGQaMApb6Oe5er7iqgcykmIAkpOBpvtvU4qa6sf2+BJX1zSzbdcixprutrpmRR0Ozm9fW7Hc0jkCx1vLdF9fy6Y4yJuX24811+zlQqRGHRUSk77HWUl7XxBfnDuPPN07jg2/NO5yQHuukAckAZCTG8PD105SQOiBRNaUSQnypKR0APOkdQTcCWGCtfd0Y8ymwwBjzRWAPcDWAtXaDMWYBsBFoAe7yNv8NK8XVjQEZebdVZrJnIIHS6vb7lX687SAtbstZJzmblE7O7ceYnGQWLN/LDbMGOxpLIPzu3a28vKqIe88ZzWVTBnHGbz7gmc92c++5Y5wOTUREpEvK65ppdlkGpcZz4cQBJ1z3S3OHMzg9gSum5hITpWnvnRCvpFRCSKdJqbV2LXBce0RrbRlwVgfbPAA80OPo+rCSqgZy0wI3T1dmkqePZkcj8L6/qYS0hGim5KW1+3mwGGO45uQ87n99I1uLqxmdk+xoPP707NI9/PH9Aq47OY+7zxyJMYazT8rhX5/t4a75I/XUWERE+pSD3gfd2T7MHJCWGMO1J4few+a+xNOnVKPvSmjQo60AKalu9Omi3l0Zia1J6fE1pS63JX/rQeaNyQ5Y8+GuuGLqIKIjDc8t29v5yn1E/pYSfvCf9ZwxOov7L59weLTB204dSlltE6+tOa4bdZ/gdmv6HhGRcFVS7el+EqiZA8S/EmOiVFMqIUNJaQA0tbg5VNtETgAv6q3Nd8vaSUpX763gUG2T4/1JW6UnxnDOuBxeXlVEU4vb6XB6bH1RJXc9s5IxOcn86cZpREce+d/olBEZjM5J4olPdvW5+VmbXW4u+uMifvbaRqdDERGRICuraWTF7nIAspID91Bd/Cc+JpLGFjcuPVCWEKCkNAAOehPFnADWlKYnxGAMHGyn+e77m4uJjDCcPjorYMfvqmtm5HGotomFm4qdDqVHiirq+cITy+gXH83jt51MUuzRLeCNMdx66jA27Ktiuffm3le8tf4Am/ZX8djinby/uW9/TyIi4ru3Nxzg1Aff5/fvbQMgW0lpn5AQ4+kmVN+s2lLp+5SUBkBxlbf5SwCT0qjICNITYtptvrtwUwknD02jX7x/p2DpidNGZTGgXxzPLe+7TXgr65u57fGl1De7eOILMzscyOqKqYPoFx/NE4t3BTfAHnp88U6GZCQwtn8y33lhHYdqNcy8iEioe2fDAb7y9ApG5yTzs8vG86urJpEY26UZA8Uh8TGe76mug5kYRPoSJaUBUFIVnD4ZmUmxx42+W1RRz+YD1b2m6W6ryAjDVdNz+WjrQfZX1jsdTpc1tbj5ylMr2Flay99umn7CAZviYyK5bmYeb204wL6KvnGua/ZWsHJPBbecMpT/u3YKVfXN/ODldX2uCbKIiPimprGFT7eXcf9/N3pGyb/jFD5/ylCumZHX+cbSKyR6a0rVr1RCgZLSACiuam2+G9ikNCPp+JrSDzaXAHDm2PbnFXPS1dPzcFt4cUWh06F0Sdu5SH911SROHZnZ6TY3zx6CtZanluwOQoQ99/jinSTFRnH1jFxOGpDC/5w7mjfXH+CV1X1zwCYREenYwepGLnzoY65/dAnFlY38+JLxxMdoxPi+JkFJqYQQtc8IgJLqBiIjDBmJMQE9TmZSLGsKK4AjI+y+v7mEIRkJjMhKDOixu2NwRgKnDM9gwfJC7pw3koheMDKwL377jmcu0m+dO5orpub6tE1uWgLnjuvPv5fu4etnjerV08OUVDXw33X7uXHWEJLjPE2+v3zacN7bWMwPX1nPrOHpDOgX73CU4WVnaS3/2tTIO+XraG5x0+Ry0+xy09RiPa9bvO9dbpq8r6MiIvjLTdMYnpXkdPgi0su9tmYfew7Vcd8FY7lo4gDy0gM3hZ0ETmvz3cLyOsYNTHE4GpGeUU1pABRXNZKVFBvwpOvY5rv1TS4WF5Ry5tjsw1OU9DbXnpzHnkN1fLbzkNOh+OTfS/fw8AcFXD8zj7vmj+zStrfOGUpFXTOvrC7ySyy1jS0UVft/9OKnl+ymxW259dShh5dFRhh+e81kXG7Lt59fq6ligshay9efXcXCPS28s6GYxQWlrN5bwbbiGvZV1FNZ34zLbYmNjiA9MYbB6QmMHZDCnkN1/GHhNqfDF5E+YPvBGvrFR3PH6cOVkPZhI7ISiYmK4M5nVnL1Xz/h7n+tZE9ZndNhiXSLakoDoLiqIaAj77bKTI6htslFo8uTMHyyvZTGFnev60/a1vkT+pP8ShQLlu/llBEZTodzQh9sKeF/W+civWxClxP9WcPSGds/mccX7+KaGXk9elDQ7HJz6+NLWbG7npkzqxl1gj6tXdHY4uKZz/Zw5phshmYeXbs+JCOR/71oHN9/eR1PLdnNLW2S1mCx1vLOxmJW7mshdnsZ2Smx5KTEHTfqcSh5f3MJawsruW1CDD++6Wyft/vFG5t49OMd3HPWKNWWisgJbT9Yw4isxF77AFt8k5uWwJtfP43b/7mcHQdrWV9UxfubS7hmRh4nx+thsvQtofvLzkEHqxuD8uQxM8mT+FY1ei48CzeXkBgTycxh6QE/dnfFRUdy2ZSBPL+8kJ9eNp6UuN4zQnBb24qrueuZlYzt75mLNCqy640KjDF8Yc4wvvPiWpbsONSjJPw3b29h2a5yoiLggTc28cRtM7u9r7ZeW7OfstombpszrN3Pr5+ZxzsbD/CLNzcxd1QmI4KY7JTXNvGt59ew0NtP+m9rlxz+LCEmkuzkWLJT4shO9iSqbf+OG5hCakJgm88HgrWW3727lcHpCcwZ2LVtv3TacJ78dBd/+mA7v71mcmACFJE+z1rL1uIazurFD7DFdyOyknjrG6djgH0VDfx+4VaeXrKb5ekRnHum+6i51EV6M/1LDYDiqoagzPGVmeT50V3ZZLHW8sHmEk4blUVsVO/tvwhw7YzBNLa4ebUXD6Lzt492EGEMj916/FykXXHplIGkJUTzxCc7u72PdzcW87ePdnDjrMFcNSqG/C0Hyd9S0u39tbLW8vjinYzKTmLOyPYTZmMMv7pyEnHRkfzPgjW0uPzffLg9y3cd4qI/fMxH2w7yo4vH8fO58fzrS7P4v2sn870LxnLdyYOZMKgfAOuLKvn30j384s3NfOO51dzw9884/Vcf8NyyPX1u9OB3NhazYV8V95w1iqguNv/PSo7lxllD+M/qIjXfEpF2rdpTzrT73+VQbRMjstWiIlRER0YQFRnB4IwEfnfNFH522QTWl7r4whPLcKn7jfQRSkr9rLHFRXldc8BH3oUjNaXVTZZN+6vZX9nAmSf1/iefEwalMLZ/Mgt66ZylNY0t/Hftfi6ZPKDH32NcdCTXzxzMuxuL2Xuo64nC3kN13LtgNRMGpfDDi8dx9pAohmYk8MB/N/U4QVy2q5wN+6q4dc7QEzbhyk6J44HLJ7JmbwV/yd/eo2N2xu22/Dm/gGsfWUJUZAQvfvVUvjB3GAOTIjh1ZCZXTM3ljjNG8KNLxvHwDdNYcMcp5H97Pht/dj7rf3oeC+89g6e/OIuTBqTw3RfXcePfP2N3WW1AY/YXt9vy+/e2MSwzkcundLGa1OuO04cTGWH4c36Bn6PzNGd/6tNdft+viATH5gNVh6+tV07L5ZLJ3bvOSO93w6zB3Dwuho+3lfK//1lHWTtz2ov0NkpK/exgdet0MMGoKfUco7LR8v7mYgDmj+n9SakxhmtPzmNtYSWb9lc5Hc5x/rt2H/XNLq7201xtN80egjGmy9PDNLa4uOtfK7HAn2+YTlx0JFERhu9deBLbSmr499I9PYrr8cU76Rcfzed8GFH4okkDuGzKQB5auI31RZU9Om5Hymoaue2JZfzqrS2cP74/r98zl0m5qT5vnxQbxYisJOaOyuTfX57Nz6+YyLrCSs77/Uc8+tGOoNXydtfbGw6waX8V95w1slvNxcHzAOH6k/N4YUUhheX+qy0trmrga/9axQ9f2cCn28v8tl8RCZ7PdhyiqcXNS189ld9eM5lBqRpVPZSdmRfFracO5dllezntVx9w49+X8PaGA06HJdIhJaV+1jpHaXZy4GtKM7zNd6uaLAs3lzA5tx9ZQWg27A+XTxlETGREr6wtXbC8kJHZSUzNS/XL/gamxnP++P48u3QPdU0tPm/3wH83sbawkl9fNZnBGUf6KJ87LofZw9P53btbqaxv7lZMheV1vL3hANfNzPN5brqfXTqBjKQYvvncahqa/Tsn2mc7yrjwDx/z6Y4y7r98Ag/fMLVH/Y0jIgw3zBrMu/9zBnNHZvHAG5v43F8+6ZUPQeBILenwrEQunTyoR/v6yrwRRBjj11rtn722kWaXm4H94vjf/6yjsUVz4on0NbvKakmIiSQ3TcloODDG8JNLx/PuN89g5rB0FheU8YOX11Hd0L3fDSKBpqTUz0qqGgDIDkJNaWxUJClxURRWu1m9t4Izx+YE/Jj+kpYYwznjc3h5VVGv+oFbUFLNit3lXNvD0XKPdducoVQ1tPDyKt+mh3ltzT7++eluvjR3GOdP6H/UZ8YYfnjxOCrqm3n4/e5NAfLUkt0YY/j8KUN93qZfQjS/vmoy20pq+M3bW7p13GO53JY/LtzG9Y8uISEmipfvPJWbvTXL/tC/XxyPfn46D98wlX0V9Vzyx0X89p0tverfHMAb6/ezpbiar581isgeTiU1oF88V8/I5fnlheyvrO9xbB9sKeG/6/bztTNH8vPPTWT7wVoe/WhHj/crIsG1p6yOwekJGnE3zIzMTuKJ22byn7vmcKi2iWv+toRnPttNbaPvD8lFgkFJqZ+VHG6+G/iaUvA04V1Z4sJaOKsP9Cdt69oZeVTUNfPexp4P2uMvzy8vJCrCcPnUntVWHWv6kDQmDErhicW7Oh18Z/vBGu57cS3TBqfy3QvGtrvO+IH9uHp6Lk98soudpV3rM1nX1MKzS/dy3vicLjffOn10FjfPHsI/Fu/scTPOg9WNfP6xz/jtu1u5ZPJAXvvaXMYP7NejfbbHGMPFkwby7jfP4NIpA/nj+wVc+NDHLN/VO+bKdXlrSUdlJ3HxJP/08frqvBG4reVvH/YseaxvcvGjV9YzIiuRL58+nHljsrlo4gD++H5Bn+mrKyIeu8pqGZqR2PmKEpKm5KXyt5tnUN/Uwg9eXs+1j3xKeW2T02GJHKak1M+KqxqIijCkB2k6isykWFrcnj6s4wemBOWY/jJnZCYD+8XxXC9pwtvscvPiyiLOHJvt92bQxhhuPXUY20pqWFzQcTJX3+TirmdWEhMVwcM3TDvhUO7fOncM0ZER/OKNTV2K5eVVRVTWN3c4DUxnvnfhWIZmJPKt59d0uxnQ4oJSLnjoY5bvKueXV07k99dOCfjco2mJMfzumik8+YWZNDS7ufpvn/LjV9ZT4/DT4tfX7qOgpIavn93zWtJWuWkJXDktl38t3XO49UZ3/PH9bew9VM8DV0w8PKr3jy4ZR0xkBP/7n/V+H934P6uKqG/RSJEi/uZ2W/aW1zMkI/DT1Unvdc64HD741jweuXk6W4truPXxpX1ulHoJXUpK/ay4qpGs5Fgi/PTjsjOZyZ7k98yx2X2uSU5khOGqGXl8vO0g+yp63sywp/K3HKS0ppFr/DTA0bEunjSAjMSYE04P86NX1rP5QDX/d+0UBnZSi5mdEsdd80fyzsZiPtle6lMM1lqeWLyLCYNSmDEkrUvxt0qIieK310xmf2U9P3tto0/bNLvclFQ1sHFfFb99Zws3/eMzUhOiefXuuVx78uCg/ts9Y3QW73zzdG45ZSj/XLKbc3/3IR/4YYqd7mhxuXnovW2MyUnmwgkD/LrvO+ePwOW2PNLNprZbi6t55KMdXDU9l9nDj0wZlJMSx7fOG8PH20p5fe1+f4XLy6sK+cZzq3lrp/o7ifjbOxuLaWpxMzHX/61RpG8xxnDu+P588+zRrCms5JBqS6WXCGzVRBgqqW4gO0hNd+HICLx9YdTd9lw9PZc/LNzGCysKueesUY7GsmD5XrKSY5k3Jisg+4+LjuSGWYN5+ANP08chxzSjWrB8L8+vKOTu+SOZ5+P3+cW5w/jXZ3v4f69v4rWvze20pm1RQamnT+jVk3uUCE4bnMad80by8AcFTMrtR3ZKHGU1TZTWNFJW00hpbROl1Y2U1TZRVtNIed3RicaV03K5//LxJMQ4cwlKjI3iJ5eO55LJA/nui2u57fFlfPm0YXzn/LFBnWj81TX72FFay19vmub3B1lDMhK5bMpAnv5sN1+ZN+LwtcIXbrflf19eT1JcFN+/8KTjPr9p9hBeXFnIz17fyOmjs+gX3/1BqQCW7TrEd19YxynDM7hkhPMPqERCyScFpXznhTUMy0zk/PH9O99AwsLY/skA7CytJaML9weRQFFNqZ+VVDWSHcQRcEdlJ5EY7WkK2xflpScwZ2QGC5bvxe3gBM8l1Q28v7mEz00b1O3pOHxx0+whRBrDPz89enqYzQeq+NEr6zlleAbfPGe0z/uLi47kuxeMZeP+Kl5cUdjp+o8v3kVmUgyXTO55rdw9Z41i/MAUfvjKBu54agXff3kdv3t3Ky+vKmLT/iqs5XA/yW+cPYr7L5/AX26cxutfm8tvr5nsWELa1vQhafz3nrncPHsIj368kxsf/YziHjR37YoWl5s/LNzGSQNSOHdcYH4o3jV/JE0tbh79uGu1pS+sKGTprkN8/4KTSE88vitCZIThgcsnUlbTyG/f6dmgV3vK6rjjqRXkpsXzl5umERWkViYi4eKZpXtoaHHz6OenB/T+Jn3L0EzPg/GujkshEijO/yoMMcXVDZw8rHvNIrvjxllDyKzdSWKA++MF0nUnD+Zr/17F3xft4PbTRzgSw39WFeFyW66eHpimu61yUuK4cOIAFizbyzfPGU1SbBQ1jS3c+fRKkuOieej6KV3uV3jJpAE8sXgnv35nCxdOGtBh38ydpbW8v7mEe84adbh/YE/EREXw3B2nsHJ3OemJMWQmxZKeGENMVN/60RMbFcn9l09gxtA07ntxHRf9YRF/vH4qp4zI6HzjHnh5VRG7yup45ObpAWvuPyIriUsmD+SpT3dzx+kj2k0wj3Wotomfv7mJk4emcdX0juewnZjbj8+fMpQnP93F56blMqUbUyhV1jdz2xNLcVvLP249mdQg9cUXCSdrCys4+6RsRmYnOx2K9CK5afFERRglpdJr9K1fj71cY4uLirpmcoIwR2mriAhDfFTfrlm4aOIALpzYn1+8uZl3HJjY2VrLc8v2Mn1IGiOzkwJ+vFvnDKW6sYWXVhZireV7L61jV1ktf7huarfmt22dIuZgdSN/yS/ocL0nP9lFdKThptmDexL+UZJiozh9dBYTBvWjf7+4PpeQtnXZlEG8cvccUuKjuPHvS/hL/vaA1d43u9z88f0CJgxK4ZxxgZ3K6e75I6lvdvHYoo77Mrf18zc2UdPQwgNXTOw0Wb733NFkJ8fyg5fX0eJydymuZpebu55ZyZ5Ddfz1pukMy9SooCL+VlbTyN5D9UzOTXU6FOlloiMjyEtPYGtxtdOhiABKSv2qpMozHUww5igNJRERht9ePYVJg/rx9WdXs76oMqjHX7mngu0Ha7k2QAMcHWtqXiqTc/vxxCe7eGrJbl5bs497zx3To5q5qYPTuGzKQB79eCeF5XXHfV7d0MwLKwq5eNLAbiW+4WJ0TjKv3j2XCyYO4Jdvbeb2p1ZQWe//gXdeWlnInkN1fPPs0QEf5GmUdxClJz7ZRWXdic9lyY4yXlhRyJdPH87onM5rVZLjovnxJePZsK+KJ49pkn4i1lp+/OoGFhWU8vMrJh41kJKI+M/aQs/9dHI3WjJI6Dv7pGze21TCk5/scjoUESWl/lRS7emLFsyBjkJFfEwkj94yg7SEaL705HIOVAanXx/A88v3khATyYWT/Dv6aUeMMdw6Zyg7Dtby41c3MG9MFl89o+fNlr97/lgiDPzyreP7+D2/vJCaxhZumzO0x8cJdUmxUTx8/VR+dPE48reUcMkfF/n1QUlTi5s/LCxgcm4/zhwbnAHK7j5zJDWNLTy2uOPa0qYWN//7n/Xkpcdzz5m+Dzp2wYT+zB+Txe/e2cL+St8GKfrHop3867M9fHXeCK4O0sMgkXC0prACY2DCII26K8f75jmjGds/mR+/uoHVeyucDkfCnJJSP2qtKQ1m891Qkp0cxz9uPZnqhma+9M9l1DUFfv7IuqYWXluzj4smdtwXMxAunDiArORYBqTE8X/XTPFLn8KBqfHcftpwXluzjxW7yw8vd7ktT366i+lD0pikJlw+McbwhbnDeO6OU2hqcfO5v3zCc8v2+GXfL6wopKiinm+cE/ha0lYnDUjhvPE5PL54J1UdzC37yEfbKSip4WeXTiA+xvc+x8YYfnbZBFzW8tNXO58i6L2NxTzwxiYumNCfb587xufjiEjXfLC5hN+/t41R2UlBvb9J35EQE8Wjn58BwMZ9VQ5HI+FOSakftY7aqea73XfSgBT+eMNUNu6r4hvPrg74iLxvrDtAbZOLa04Obm1NbFQkL331VP5z9xzSfBh8xld3nDGC7ORY7n994+Gy+2BzCbvL6rj11KF+O064aB2dd+bQdL774jq+/fwaGppd3d5fY4uLh9/fxtTBqcwbHZiphzrytTNHUdXQwj/baaa1u6yWP75fwIUT+zO/G7W3eekJ3HPWKN7acICFm4o7XG/DvkrueXYVEwf143d+ehgjIu277YllAAxOV39t6dig1HjioyPVt1Qcp6TUj4qrG4mKMKRrBMkeOXNsDv970Tje2VjML9/eHNBjLVi+l2GZicwYErwRk1vlpSf4vX9nYmwU3z5vDKv3VvDa2n0APPHJLvqnxHH+BM1P1x0ZSbE8+YWZfO3MkTy/opAr/vwJu7o5WuGCZXvZV9nA/wSxlrTVhEH9OGtsNn9ftJOaxiOtEKy1/PCVDURHRvCji8d3e/9fPm04o3OS+NErG9pt5VBS1cCXnlxOv/ho/v75GV2qjRWRrqlt8//4l08b5mAk0ttFRBhG5SRRUFLjdCgS5pSU+lHrHKV6+t9zt80Zyk2zB/O3D3f4rdnksXaW1rJ05yGunpEb9AQhkK6clsuEQSk8+OZm1hZWsKiglJtPGUK05qfrtsgIw73njuHxW09mX0U9lzy8iJ+8uoEPtpT4XHPa0OziTx9sZ8aQNOY6NK/w184aRUVdM08vOTIo0etr9/PR1oPce+5o+vfr/kOS6MgIHrhiIkUV9Ty0cNtRn9U3ufjSP5dTWd/MP245Wf3uRQJsg7cp5j9umcEsDSQmnRiVncyiglJeWtn5fOcigaJfqX5UUt1Aln5s+YUxhp9cMp7TRmXyg5fX88n2Ur8f4/nle4kwniQulEREGH540Tj2VzZw2+PLiI2K4IaZ/psGJpzNH5vN61+by+zhGTy7bA+3Pb6MyT99h1seW8oTi3eesAb12aV7OFDlTC1pqyl5qZw+OotHP9pBXVMLVQ3N/Oz1jUwc5JlztKdOHprOtTPy+MfHO9l8wPOj2O22fPO51awrquQP101l3MCUHh9HRI62+UAVpTWecS2aWtw87h3UbGKuBjiSzt1++nAAXlm9z+FIJJwpKfWj4qoGcpLVn9RfoiIj+NON0xiWmchXn17JjoP+a1rS4nLz4spC5o/JJicEHyTMGp7B+eP7U1bbxBVTB/m132q4y0tP4NHPz2D1j87lyS/M5IZZg9l7qI6fvLaReb/JZ96vPziuFrWh2cWf87cza1h6j6b+8YevnzWSstom/vXZHn7z9hbKahp54IoJRPqphcd9F4wlJT6aH7y8Hrfb8ut3tvDWhgP84MKTODvAc7LKEcaYSGPMKmPM69736caYd40x27x/g99nQQLm/N9/zJwH3wfg4fe38eb6A/zPOaM1BZj4ZEz/ZOaNyeJQbZPToUgY03BsflRS3cisYWom408pcdE8duvJXP6nxXzhiWW8fKd/Bgb6eFspxVWN/PTS0J2O4gcXnUR5XRN3+GG6GTleXHQkZ4zO4ozRWXCJZ7Cg/C0Hyd9SwrPL9vDEJ7uIjYpg9vAMUuKjKalu5A/XT3W8qfj0IenMGZnBH98voKqhmVtOGerXUZnTEmP4/oUn8a3n1/CVp1fwzsZibpg1mC/OVb+2IPs6sAlorZq+D1horX3QGHOf9/13nQpO/KfaO6J2Y4ubq/7yCct3l3P5lIHcc5bvUzuJpCfGsK1Y/UrFOaop9ZOGZhcVdc1kq6bU7/LSE3jk8zPYV9nAV55eQVOLu8f7XLB8LxmJMUGbJ9IJeekJPHfHKQzL1MiLwTAkI5FbTh3K47fNPFyLev3Mwew5VMdra/Yxd2Qms3tJ3657zhxFZX0zWUmx3HvuaL/v/8ppg5g1LJ13NhZz2qhMfnrpeMeT8XBijMkFLgL+3mbxZcCT3tdPApcHOSwJALfbsrbwyDzK64oq+fZ5Y/jlVZMcjEr6oozEGMpqG50OQ8KYakr95GC1d47SEGwK2htMH5LGr6+axNefXc33X17Hr3twwy2raeS9TcXccspQYqL0XEb876haVKCwvI7UXjQq96zhGdx3wVhOHppGcly03/dvjOE3V0/miU92cc9ZozTIVvD9HvgOkNxmWY61dj+AtXa/MSZ0n8iFicq6Zi5++GP2HqoH4F9fnsW0wWnERWtka+m69MRYGprd1DW1kBCj9ECCT//q/KSkWnOUBtplUwaxs7SW37+3jeFZiYzr5n5eXlVEs8ty9YzQbborvUtuWoLTIRznKwFu1p2XnsAPL+7u/6XSXcaYi4ESa+0KY8y8bmx/O3A7QE5ODvn5+X6Jq6amxm/7ClVdKaMNpS7+uKqBhjaDf5fvWMeSvaHfIkH/lnzT1XI6WOhpBv7f9z4iKyE8HiTq35JvglVOSkr9pLjKU1OqQQUC6+tnjWJnaS2/emsL14yO5tS57i7VdlprWbB8L5PzUhnTP7nzDURE+pY5wKXGmAuBOCDFGPM0UGyMGeCtJR0AlLS3sbX2EeARgBkzZth58+b5Jaj8/Hz8ta9Q5WsZbT5QxZf+sIgWN1w4sT9vrDsAwEXnzA9whL2D/i35pqvl1LKxmMfWL2f0xGlMzksNWFy9if4t+SZY5aSk1E+Kqzw1pTmqKQ0oYwy/vHISdU0uFmwsZsVDH/GjS8YfbibZmbWFlWwtruGBKyYEOFIRkeCz1n4P+B6At6b0W9bam4wxvwZuAR70/n3FqRilZz7bcYgWt+W9/zmdwemJ3DTrEIXl9U6HJX1cepKni4lG4BWnhEf9fBCUVDcSHWlI60X9xkJVXHQkj35+Bt+YFovLbbnlsaV86cllJ5wjstWC5XuJi47gkskDgxCpiEiv8SBwjjFmG3CO9730QTtLa0mMiWREVhIxURGcOjKTa05WdxTpmQzvzAaPLd7JM5/txuW2Dkck4abTpNQYk2eM+cAYs8kYs8EY83Xv8g7nPDPGfM8YU2CM2WKMOS+QJ9BbFFc1kJUUS4Sf5vqTzk3JjuLtb57OfReM5dPtZZz7fx/xy7c2U9vY0u769U0uXl29jwsnDCAlAIO7iIj0JtbafGvtxd7XZdbas6y1o7x/Dzkdn3TurfUH+MmrG44adX5naS3DshI1orX4VW5aAqcMz+DjbaX84OX1nPnbfP70QYFfZjwQ8YUvzXdbgHuttSuNMcnACmPMu8CttDPnmTFmHHAdMB4YCLxnjBltrXV1sP+QUFLVSLZG3g262KhIvnLGCD43dRAPvrWZv+Rv56WVhdx3wVgunzLoqJv22xsOUN3YogGORESk1ysoqeYrT68AICYqgltPHcqm/VUUlNQwbUhaJ1uLdE1khOHpL83iQFUDa/dW8M9Pd/Prt7fw2c5DPHHryap0kYDrtKbUWrvfWrvS+7oaz2Tcg+h4zrPLgGettY3W2p1AATDTz3H3OiXVDepP6qDslDh+d80UXrrzVHJS4vjmc2u48i+fsLaw4vA6C5bvZXB6ArOGpTsXqIiIiA827KsCYOawdB75aAenPvg+X3xyOUUV9QzL6H0jekvfFxlhGJQazwUTB/Dv22dz/2Xj+WjrQR5bvNPp0CQMdKlPqTFmKDAV+Ixj5jwDWuc8GwTsbbNZoXdZSCuuatTIu73AtMFp/OfOOfzqqknsOVTHZX9azHdfWMvKPeV8sr2Mq6fn6mmfiIj0ejtLazEGHv38DC6c2J8bZg3m8dtO5htnj1IfUgmKm2YP4ZxxOfzq7S3sOFjjdDgS4nwefdcYkwS8CHzDWlt1gr4M7X1wXG/pUJoLrcllqaxvprZsH/n5pUE9NoTvPEsnOu9s4Gezonh1u5sXVuzlueV7McDApr3k5xcFM0y/0ncdPsLxnCF8z1vkWDtLaxnYL55+8dH8+cbph5fPH5N9gq1E/McYw8+vmMhpv3qfv324g19eNcnpkCSE+ZSUGmOi8SSkz1hrX/Iu7mjOs0Kg7SO8XGDfsfsMpbnQ9h6qg3c/YPbkk5jnQH/FcJ1nyZfzvvAc2H6whgff3Ez/lDiuvKBvTwWj7zp8hOM5Q/iet0hbNY0tvL+5hClhMl+k9F5ZybFcPT2Pfy/dw7CsRC6fMoj+/dQyUPzPl9F3DfAPYJO19ndtPnoVz1xncPScZ68C1xljYo0xw4BRwFL/hdz7tM5Rmp2sPqW90YisJB79/Azuv7xvJ6QiIhIevvncaqobWhiZneR0KCJ885zR5KTE8eCbmzntV+9z34trPRUyIn7kS03pHOBmYJ0xZrV32ffxzHG2wBjzRWAPcDWAtXaDMWYBsBHPyL13hfrIu8VVjQDkaPRdERER6YHK+mbyt5QwKbcf95w5yulwREhPjOHNb5zG+sJK3lx/gOeW7+W/a/dz34VjmZKXyviB/ZwOUUJAp0mptXYR7fcTBTirg20eAB7oQVx9SmtNqZJSERER6Y5mt+W372zhrfUHaHZZfnLpeNISY5wOSwSAlLhoTh2ZyakjM7njjOF8+Z8r+MHL6wG4dPJAvnvBWAalxjscpfRlPg90JB0rqW4kOtKQlhDtdCgiIiLSB720rZk3dxYwtn8y3z5vDFPVn1R6qdy0BP795Vm8sKKQXWW1vLiiiA82l/CLKydy8aSBTocnfZSSUj8oqWogOzmOE4xILCIiItKhXZUupg5O5eU75zgdikinUhNi+NJpwwG4/bQRfP25VfzPc2uYnJtKXrrm0ZWu69I8pdK+4uoGslM0yJGIiIh0T0mdZYh+zEsfNDgjgT/dMA1j4Mv/XM6m/VVOhyR9kJJSPyipatTIuyIiItItzS43hxosg5WUSh81MDWev948ndKaJi7/02LW7K1wOiTpY5SU+kFxVYMGORIREZFu2VdRjwVylZRKHzZ/TDZvfv00MpNiue2JZawvqnQ6JOlDlJT2UEOzi6qGFiWlIiIi0mUb9lVyxq/zAVRTKn1eVnIsT31xJjGREXznhbW43dbpkKSPUFLaQyXeOUqz1HxXREREfFTf5OKB/27k4j8uAiA11jC2f7LDUYn03PCsJL593hg27q9iyY4yp8ORPkKj7/ZQcbXmKBURERHfHaxu5IKHPqa0ppErp+Xy3QvGsHHFElITNC+phIY5IzMB2F5ay6ne1yInoqS0h4qrWpNS1ZSKiIhIx6y1GGP4S/52SmsaeeCKCVx/8mAiIgwbnQ5OxI+yk2OJjjQUldc7HYr0EUpKe6i1+W52smpKRUREpH3ffn4Nr67ZR25aPNsP1nL9zDxunDXE6bBEAiIiwjAwNZ7C8jqnQ5E+QklpDxVXNxAdaUhLiHY6FBEREemFGppdvL52P2P7J5OTEsf0IWn8+JLxToclElC5afEUVaimVHyjpLSHPHOUxmGMcToUERER6YU+3VFGfbOLb54zmnljsp0ORyQoBqXGs2B5IaU1jWQmqZubnJhG3+2hkuoGstWfVERERDqwaFspsVERzB6e4XQoIkEzLDMJgJkPvMePXll/eBwWkfaoprSHiqsaGZmV5HQYIiIi0kst3XmIKXmpxEVHOh2KSNDceupQxvZP5v3NJfzz0928sKKQv908ndNGZTkdmvRCqintoeKqBo28KyIiIsdZuKmYiT9+m3VFlcwalu50OCJBFR8Tyfyx2dx/+QQW3nsGeWkJ3PPvVZTVNDodmvRCSkp7oL7JRXVDC9mao1RERESO8fePd1Ld2MKAfnGcN6G/0+GIOGZEVhIPXT+F8rpmXl5V5HQ40gup+W4PlFR72sZnJ6umVERERI62q6yWz00bxO+umeJ0KCKOG5OTTExkBAdVUyrtUE1pDxR75yjNUU2piIiItFHf5GJ/ZQPDMhKdDkWkVzDGkJ4Yw6GaJqdDkV5INaU9cLimVH1KRURExKusppGCkhoAhmYqKRVplZ4Yw6FaJaVyPCWlPXC4pjRZNaUiIiLhaltxNZ/uKKO8tpknPtlJeV3z4c+GKSkVOSwjKYYyJaXSDiWlPVBS1UBMZASpCdFOhyIiIiIOWLmnnNv/uYJSbz+5YZmJXDZlEM0uN7vKahmZrWnjRFqlJ8awu6zO6TCkF1JS2gMl1Y1kp8RijHE6FBEREQmyj7Ye5POPLSXCwL3njGbG0HRmDUsnIkK/C0Tao+a70hElpT1QXNWgkXdFRETCkLWWn7y2gWGZifzzCzPJS09wOiSRXi89IYaaxhYaW1zERkU6HY70Ihp9tweKqxo08q6IiEgYWrLjEDsO1vLVeSOUkIr4KD0pBkC1pXIcJaU9UFLdqKRUREQkzGwrruaWx5eSlhDNRRMHOB2OSJ8xKDUegFV7KpwNRHodJaXdVNfUQnVDC1lqvisiIhJWXlm9j6YWN8/dcQqJseoJJeKruSMzGZ6VyJ3PrOSpT3c5HY70IkpKu6mkdToY1ZSKiIiEhcr6Zt7bWMx/Vhcxe3g6o3OSnQ5JpE+Jiozg4eunAbC4oMzhaKQ30eO9biqpbk1KVVMqIiISyrYWV3Pfi2tZ6W1ymBgTyU8vHe9sUCJ91LiBKUzO7UdDi8vpUKQXUVLaTcVVDQBkJ6umVEREJFS53JY7n1lJRV0T/3POaGYMSWPG0HRiotTYTKS7YqMjqW9SUipHKCntptakVDWlIiIioWV3WS1RkRG8unofr6wuoqCkhr/eNI3zJ2hQIxF/iI+OpKK+2ekwpBdRUtpNB6sbiYmKoF98tNOhiIiIiJ+U1jRy1m8/pMVtAZg5NJ37LxvPeeP7OxyZSOiIi46gsUo1pXKEktJuKq5qIDs5FmOM06GIiIiIn6wtrKDFbblk8kCunp7L6aOznA5JJOTERUdS36ykVI5QUtpNxVWao1RERCTUrCuswhh48HMTNd2LSIDER0fSoKRU2lAv/W4qqW5Qf1IREelVjDF5xpgPjDGbjDEbjDFf9y5PN8a8a4zZ5v2b5nSsvU2zy80rq4t45rPdDM9MVEIqEkBxGuhIjqGktJtKqho18q6IiPQ2LcC91tqTgNnAXcaYccB9wEJr7Shgofe9tPH88kK+/uxqSqob1X9UJMBioyNoaHE7HYb0InoM2A11TS1UN7aQrZpSERHpRay1+4H93tfVxphNwCDgMmCed7UngXzguw6E2CvVN7n456e7yEuP5/W7T6NfggYxFAmk+OhImlrcuN2WiAiNzyKqKe2WkqpGAHJUUyoiIr2UMWYoMBX4DMjxJqytiWu2g6H1KtZavvTPZWw+UM2954xRQioSBHHRkQA0tKgJr3h0WlNqjHkMuBgosdZO8C5LB54DhgK7gGusteXez74HfBFwAfdYa98OSOQOap2jVDWlIiLSGxljkoAXgW9Ya6t8HSneGHM7cDtATk4O+fn5fomnpqbGb/vyt41lLhYXNHDdmBhSK7eRn7/NkTh6cxn1Jion3/T2ctq72zNH6cL8j0mOcaamtLeXUW8RrHLypfnuE8DDwD/bLGvtm/KgMeY+7/vvevutXAeMBwYC7xljRltrQ+oxSHG1t6ZUo++KiEgvY4yJxpOQPmOtfcm7uNgYM8Bau98YMwAoaW9ba+0jwCMAM2bMsPPmzfNLTPn5+fhrXz11oLKBj7YeZF9lPdGRETy2cSe5afH85KYzDtfeOKE3lVFvpnLyTW8vp+Jle3hm0zqmzZzNoNR4R2Lo7WXUWwSrnDpNSq21H3mbALXVUd+Uy4BnrbWNwE5jTAEwE/jUT/H2CiXemlI13xURkd7EeKpE/wFsstb+rs1HrwK3AA96/77iQHiO219Zz/m//5jK+ubDy0ZlJ/HHG6Y6mpCKhJvDzXc1LYx4dXego6P6phhjWvumDAKWtFmv0LsspJRUNxITFUFKvMaJEhGRXmUOcDOwzhiz2rvs+3iS0QXGmC8Ce4CrnQnPOdZa7ntxHU0tbl6+81ROGpBCk8tNSpz6kIoEW2yUklI5mr+zqvYahdt2V+zD/VbWbmugX7Tlww8/DOhxfBWubeLD8bzD8ZwhPM87HM8Zwve8/cVau4j278UAZwUzlt6kqKKeu/+1klV7KvjZZeOZOtgzTatqR0WcER+jpFSO1t2ktKO+KYVAXpv1coF97e2gL/db+evWTxkSY5k379SAHsdX4domPhzPOxzPGcLzvMPxnCF8z1v8q6HZxZvr97Nidzkb91VRUFKDBX548ThumjXE6fBEwl5clGcCkIZmzVUqHt1NSjvqm/Iq8C9jzO/wDHQ0Clja0yB7m5LqRsb2T3Y6DBEREWmjsr6ZxQWl/O3D7awprCQxJpLBGYmMH9iPn1w6njG6d4v0CupTKsfyZUqYf+MZ1CjTGFMI/JgO+qZYazcYYxYAG4EW4K5QG3kXPPOUnj4qy+kwREREBHC5La+sLuJXb23hQFUDSbFRPHzDVC6aOABfp8MRkeBpbb5br6RUvHwZfff6Dj5qt2+KtfYB4IGeBNWb1Ta2UNPYoulgREREeolHPtrBL9/aTFZyLM98aRYnD00nxts8UER6nzjvQEcLlhcyb0w2SbEaPDTc6V9AF5V45yjNTo51OBIREZHw9db6A3y2s4x9FfW8u7GYs0/K4W83TycyQjWjIr1d/35xzB2ZyUdbDzLhx28zd2Qmv7tmMtmq9AlbSkq7qLh1jlL9TyMiIuKIdzYc4CtPryAhJpLMpFiunJbLTy4dr4RUpI+IiYrg6S/NYvmuQ7y7sZinluzmukeX8KsrJzFjaLrT4YkDlJR20ZGkVDWlIiIiTvi/97YxOieJ17429/B8hyLS98wYms6MoemcMSaLm/+xlO+8sJb3vzXP6bDEAepw0UUHDzffVU2piIhIMB2sbuTJT3axaX8VN80eooRUJEScOiKTu+aNYFdZrUbkDVOqKe2i4qoGYqMiSIlX0YmIiATDW+sP8PM3NrHnUB0AuWnxXDJpoMNRiYg/jchOwm1hV1ktY/unOB2OBJkyqy4qrmokJyVOQ8yLiIgEwV8/3M6Db25mwqAU/veik5iSl8qUvFSiItXYSySUjMr2zCNcUFKjpDQMKSntopLqBo28KyIiEgT1TS7+sHAbZ47N5i83TVNzXZEQNjwrkQgDzyzZQ1V9C5dMHkByXLTTYUmQ6DFjF5V4a0pFREQksPK3lFDX5OKLc4cpIRUJcXHRkXzz7NEs3XWI77+8jlN/8T6/eHMTVQ3NTocmQaCktIuKqxrI1si7IiIiAff62v1kJsUwa5imiBAJB187axQbfnoeL995KmeMyeLRj3Zw8R8Wsdfbn1xCl5LSLqhpbKG2yaWRd0VERAKsrqmFhZuLOX9Cf/UfFQkjcdGRTB2cxsM3TGPBHadQXtvEvN/k88hH250OTQJIV/kuKNEcpSIiIkHx0dZSGprdXDRRo+yKhKsZQ9N55e45nH1SNj9/YzP/9+5WrLVOhyUBoKS0C4qrPHOUqk+piIhIYH26vZSEmEimD0lzOhQRcdDwrCT+fON0rpqey0MLt/H3j3c6HZIEgJLSLthXUQ+g0XdFREQCqKymkY+2lXLy0HRiovRTRSTcRUYYfnXlJE4dkcETn+xSbWkI0pXeR9Za/vnpLgb2i2NIRqLT4YiIiISkl1YWMuvnC9lZWsulk9V0V0Q8IiIMV07LpaiingXL9+J2KzENJUpKffT2hgOsKazkG+eM1lNbERERP2t2ufntO1u49/k1TMrtx9vfOJ0rp+c6HZaI9CLnTejPmJxkvvviOk598H3ue3EtFXVNToclfhDldAB9QYvLzW/e2crI7CQ+N3WQ0+GIiIiElPomF3f9ayXvby5hSl4qv71mCsMy1SpJRI6WFBvFf++Zy3/X7eedjcU8u2wvVQ3NPHTdVKI1SnefpqTUBy+tKqKgpIa/3jRNw9KLiIj4SVVDM2+tO8C/l+1h9d4K/t/lE7hp9hCnwxKRXiwqMoLLpgzisimDGDeggF+/vYVPt7/HLacO5YZZgzV1Yx+lpLQTDc0ufv/uVibn9uO88f2dDkdERCRk3Pn0ShYVlJKWEM0fr5/KxZPUh1REfHfnvBGMG5jCvz7bw+/f28bv39vGtMGpXDRpIJdMHqAEtQ9RUtqJZz7bw77KBn5z9WSMMU6HIyIiEhKW7TrEooJSvnP+GL5y+ggiInSPFZGuMcYwf0w288dks3FfFR9sKeE/q4q4//WN/OKNTZw7PoeLJw3ktFGZJMdFOx2unICS0hOoaWzhTx8UMHdkJqeOzHQ6HBERkZBQUdfET17dQGZSDLedOkwJqYj02LiBKYwbmMJd80ey42AN/166hxdWFPLGugNERRjy0hO4fmYeXz5tuCqaeiElpSfw9493cKi2iW+fN8bpUEREREJCZX0zFz70MfsqG/jxJeOIj4l0OiQRCTHDs5L4wUXj+O75Y1m5p4IPtpSwcnc5P39jMx9tLeWGWYNxN1mstUpQewklpR0oq2nk0Y92cMGE/kzOS3U6HBERkT5t4aZiFhWUsmTHIQ5UNfCnG6Zx4USN1SAigRMVGcHMYenMHJaOtZY/LCzgqSW7uPOZlQB875N3GJyewOicZGYPT+f8CQPoF69mvk5QUtqBP+dvp77Zxb3nqpZURESkOxqaXby94QD/XNXAiuLlxEdHMiQjgT/dMI0LJg5wOjwRCSPGGL5+9ijumj+CjwtKeefTNcSkDWDPoTo+3HqQl1cV8diiXdw0ezCTclMZOyCZ2Ci15AgWJaXtKKqo56lPd3P19DxGZic5HY6IiEifZAx854W1RODmm2eP5s75IzSXoIg4KioygvljsjH7o5k3bwIALrfl3Y3F/OiV9fzwlQ0AxERGcN6E/vz+2ilEqt97wCkpbcfv390KBr5+9iinQxEREemzYqMiefPrp7Fz3TLOOlP3VBHpnSIjDOdP6M9543MoqqhnbWElH28r5d9L9zAoNZ6vnjGCfglq1htISkqPUVBSzYsrC/nCnGEMTI13OhwREZE+bXhWEntUyyAifYAxhty0BHLTErhgQn9cbjd//XA7f/1wO8OzEvnKGSO4YuogtfgIAJXoMX7z9lYSYqK4c/5Ip0MREREREREHGGP45ZWTePILM/neBWOJj47kOy+s5eQH3uMHL6+jxeV2OsSQoprSNtbsreCtDQf45tmjSU+McTocERERERFxiDGGM0ZnccboLG4/fTj5Ww7yr6V7eOazPfxnVREzh6VzxxkjmJKXSly0BkXqCSWlbfzq7c1kJMbwxdOGOR2KiIiIiIj0EsYY5o/NZv7YbN7ecIDFBaW8vLKID7YsITEmkiun5zI4PYFLpwwkOznO6XD7HCWlXou2lbK4oIwfXTyOpFgVi4iIiIiIHO+88f05b3x/vnbmKFbtKeflVUU8u3QvTS43D723jXEDUxielcTwzEROH53FmP7JTofc6yn7Aqy1/OrtzQxKjefG2YOdDkdERERERHq5rORYzh3fn3PH98day9biGv6xaAfbD9by9oYDHKpt4rfvbuGueSO5bMogBmckOB1yr6WkFHhr/QHWFlby66smaZJcERERERHpEmMMY/on86urJh9eVlhexy2PLeW3727loYXbuGjSAPr3iyMzMZaMpBiyk+MYPzCFNI1lo6S0xeXmN+9sYVR2Ep+blut0OCIiIiIiEgJy0xJ473/OYF9lA//37lYWF5RSVtNE0zEj984ZmcE3zx7NmP7JJMVGYUz4TaMV9knpSyuL2H6wlr/dPJ1IzaMmIiIiIiJ+YoxhUGo8v7naU4NqraW6sYWymiaKyutZsbucJz/dxVV//RSAuOgIspJjyUqKZfqQNEbnJNO/Xxxj+ieTmRhLRIjmK2GdlDY0u/j9e1uZkpfKueNynA5HRERERERCmDGGlLhoUuKiGZaZyNxRmXxh7lDe31xCcVUDB6sbKa1poqiinscX76LFbdtsC8mxUSTHRZOXHs/JQ9PJToljaEYCJw9N92laGpfb0uxyExMZQUOLixdXFtHicuNyW95Yt5/+/eIYmZ3MgH5x9O8XR0G5i3FVDWSnBHZE4ZBKSt/bWMyqAy1Uri6iqcVNs8vS1OLy/HW5vcs8/zW1uNl9qI59lQ385prJYVlNLiIiIiIizkqOi+ayKYOOW97Q7KKkqpGiino27a+ioq6JqoYWKuub2bivij99UECbnJW0hGhyUuIOJ5Q5KXH0T4lj84FqdpTWkhwXxYpd5RyoagAgwnDU9sMzEzlY08ib6w9g2yyPzt7PrXMCO2VmSCWlX3l6hedpwurVHa4THWmIjowgOjKCmKgIbpo9mFNHZAYvSBERERERkU7ERUcyOCOBwRkJnDIi47jPW1xuymqbWLWngm3F1RyoaqC4qoH9lQ2sK6qktKYJgMgIw/iBKRSW1zEkI4HPnzqEphZPJd1po7IY2z+Z+mYX/VPiiIgwNLvclFQ3cqCynk+XreTsILQoDVhSaow5H3gIiAT+bq19MFDHavWfu+awauUKTp09kxhv0ulJQI3ndUREyLbDFhERERGR8BEVGUFOShznT+jP+RP6H/d5U4ub4qoGYqMiOm1+m9bmdXRkBINS4xmUGk/1zihy0wI/lU1AklJjTCTwJ+AcoBBYZox51Vq7MRDHazVhUD9Kt0UwIispkIcRERHpk5x4YCwiIs6IiYogL71vzI0aEaD9zgQKrLU7rLVNwLPAZQE6loiIiHSizQPjC4BxwPXGmHHORiUiIhK4pHQQsLfN+0LvMhEREXGGHhiLiEivZGzboZX8tVNjrgbOs9Z+yfv+ZmCmtfZrbda5HbgdICcnZ/qzzz7rl2PX1NSQlBRezXfD8ZwhPM87HM8ZwvO8w/GcwX/nPX/+/BXW2hl+CClkGGOuAs4/5t48y1p7d5t1dG92iMrINyon36icOqcy8o0/y+lE9+ZADXRUCOS1eZ8L7Gu7grX2EeARgBkzZth58+b55cD5+fn4a199RTieM4TneYfjOUN4nnc4njOE73kHSXsj/R31ZFr3ZueojHyjcvKNyqlzKiPfBKucAtV8dxkwyhgzzBgTA1wHvBqgY4mIiEjnOn1gLCIi4oSAJKXW2hbgbuBtYBOwwFq7IRDHEhEREZ/ogbGIiPRKAZun1Fr7BvBGoPYvIiIivrPWthhjWh8YRwKP6YGxiIj0BgFLSkVERKR30QNjERHpjQLVp1RERERERESkU0pKRURERERExDEBmae0y0EYcxDY7afdZQKlftpXXxGO5wzhed7heM4QnucdjucM/jvvIdbaLD/sJ2zp3hx0KiPfqJx8o3LqnMrIN/4spw7vzb0iKfUnY8zycJswPRzPGcLzvMPxnCE8zzsczxnC97xDnb7XzqmMfKNy8o3KqXMqI98Eq5zUfFdEREREREQco6RUREREREREHBOKSekjTgfggHA8ZwjP8w7Hc4bwPO9wPGcI3/MOdfpeO6cy8o3KyTcqp86pjHwTlHIKuT6lIiIiIiIi0neEYk2piIiIiIiI9BEhk5QaY843xmwxxhQYY+5zOp5gMcbsMsasM8asNsYsdzqeQDDGPGaMKTHGrG+zLN0Y864xZpv3b5qTMQZCB+f9E2NMkff7Xm2MudDJGP3NGJNnjPnAGLPJGLPBGPN17/KQ/r5PcN4h+30bY+KMMUuNMWu85/xT7/KQ/q7DTbjem9vT1XuZMeZ73nLbYow5z5mog6s794AwLacuXz/DsZwAjDGRxphVxpjXve9VRsdoL5dwopxCIik1xkQCfwIuAMYB1xtjxjkbVVDNt9ZOCeFhrZ8Azj9m2X3AQmvtKGCh932oeYLjzxvg/7zf9xRr7RtBjinQWoB7rbUnAbOBu7z/L4f6993ReUPoft+NwJnW2snAFOB8Y8xsQv+7Dhu6Nx/nCXy8l3nL6TpgvHebP3vLM9R16R4QxuXUpetnGJcTwNeBTW3eq4zad2wuEfRyComkFJgJFFhrd1hrm4Bngcscjkn8xFr7EXDomMWXAU96Xz8JXB7MmIKhg/MOadba/dbald7X1XhuJIMI8e/7BOcdsqxHjfdttPc/S4h/12FG9+Y2ungvuwx41lrbaK3dCRTgKc+Q1o17QLiWU1evn2FZTsaYXOAi4O9tFquMfBP0cgqVpHQQsLfN+0JC/AddGxZ4xxizwhhzu9PBBFGOtXY/eG5iQLbD8QTT3caYtd6mYCHbtNEYMxSYCnxGGH3fx5w3hPD37W1WtRooAd611obVdx0Gwvne7KuO/r2Hfdn5eA8I23Lq4vUzXMvp98B3AHebZSqj47WXSwS9nEIlKTXtLAuXYYXnWGun4WkedZcx5nSnA5KA+gswAk9znf3Abx2NJkCMMUnAi8A3rLVVTscTLO2cd0h/39Zal7V2CpALzDTGTHA4JPGvcL4391RYl10X7gFhW05dvH6GXTkZYy4GSqy1K3zdpJ1lIV1GbXQllwhYOYVKUloI5LV5nwvscyiWoLLW7vP+LQFeJnyaGhQbYwYAeP+WOBxPUFhri703IjfwKCH4fRtjovH8GHnGWvuSd3HIf9/tnXc4fN8A1toKIB9P/5SQ/67DSNjem7ugo3/vYVt2XbwHhG05tfLx+hmO5TQHuNQYswtP14EzjTFPozI6Tge5RNDLKVSS0mXAKGPMMGNMDJ4OuK86HFPAGWMSjTHJra+Bc4H1J94qZLwK3OJ9fQvwioOxBE3rBcLrCkLs+zbGGOAfwCZr7e/afBTS33dH5x3K37cxJssYk+p9HQ+cDWwmxL/rMBOW9+Yu6ujf+6vAdcaYWGPMMGAUsNSB+IKqG/eAcC2nrl4/w66crLXfs9bmWmuH4rn2vG+tvQmV0VFOkEsEvZyi/LETp1lrW4wxdwNvA5HAY9baDQ6HFQw5wMueazhRwL+stW85G5L/GWP+DcwDMo0xhcCPgQeBBcaYLwJ7gKudizAwOjjvecaYKXiaSuwC7nAqvgCZA9wMrPP2lQH4PqH/fXd03teH8Pc9AHjSO2pfBLDAWvu6MeZTQvu7DhthfG9uV1fuZdbaDcaYBcBGPCPS3mWtdTkSeHB16R4QxuXUpetnGJdTe/Rv6Wjt5hLGmGUEuZyMteHSXFpERERERER6m1BpvisiIiIiIiJ9kJJSERERERERcYySUhEREREREXGMklIRERERERFxjJJSERERERERcYySUhEREREREXGMklIRERERERFxjJJSERERERERccz/B06c3h5J/CbJAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████| 30001/30001 [04:14<00:00, 118.09it/s]\n"
     ]
    }
   ],
   "source": [
    "train_agent(env, agent, target_network, optimizer, td_loss_fn=td_loss_dqn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "final score(Dueling DQN): 254\n"
     ]
    }
   ],
   "source": [
    "final_score = evaluate(\n",
    "  make_env(ENV_NAME),\n",
    "  agent, n_games=30, greedy=True, t_max=1000\n",
    ")\n",
    "print('final score(Dueling DQN): {:.0f}'.format(final_score))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "In this notebook we saw how to train a DQN agent with experience replay and target networks. We also saw variant **Dueling DQN** . As discussed above, we could also combine DDQN with Dueling type of architecture giving us **Dueling DDQN.**\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
